Java-集合框架

一、集合框架的概述
* 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
* 说明：此时的存储，主要指内存层面的存储，不涉及到持久化的存储（.txt,.jpg，数据库中的存储）
*
* 2.1数组在存储多个数据方面的特点：
*      》一旦初始化之后，其长度就确定了
*      》数组一旦定义好了，其元素的类型也确定了。我们只能操作指定类型的数据了。比如String [] arr;
* 2.2 数组在存储多个数据方面的缺点
*      》一旦初始化之后，其长度就不可修改
*      》数组中提供的方法非常有限，对于添加、删除插入数据等操作，非常不方便，同时效率不高。
*      》获取数组中的实际元素的个数的需求，数组没有现成的属性或方法可用
*      》数组存储数据的特点：有序、可重复。对于无序、不可重复的需求不能满足。
*
*二、集合框架
*  Collection接口：单列集合，用来存储一个一个的对象
*      子接口List：存储有序的、可重复的数据    “动态”数组
*              ArrayList
*              LinkedList
*              Vector
*
*
*      子接口Set：存储无序的、不可重复的数据
*              HashSet
*                  LinkedHashSet
*              TreeSet
*
*  Map接口：双列集合，用来存储一对（key-value）一对的数据   y=f(x)
*      HashMap
*      LinkedHashMap
*      TreeMap
*      Hashtable
*      Properties
*
*三、Collection接口中的方法

1.add(Object e);
2.add(Object e):将元素e添加到集合当中
3.size()：获取添加的元素的个数
4.addAll(Collection c):将c集合中的元素添加到当前集合中
5.clear():清空集合元素
6.isEmpty():判断当前集合是否为空
7.contains(Object obj):判断当前集合中是否包含obj
8.contains(Object obj)调用的是equals
9.containsAll(Collection c):判断形参c中所有元素是否都存在于当前集合中
10.remove():移除某一个数据（也需要重写类中的equals方法）
11.removeAll(Collection c):从当前集合中移除c中所有元素（差集）
12.retainAll(Collection c):获取当前结合与c集合的交集，并返回结果给当前集合
13.equals(Object obj):判断当前集合和形参集合的元素是否都相同
14.hashcode():放回当前对象的hash值，自定义对象需要重写hashcode()方法
15.toArray()：集合  --->数组
16.Arrays.asList(T... a):数组 -->集合
17.iterator():返回Iterator接口的实例，用于遍历集合元素

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.*;

/**
 *
 *
 *
 *
 * 一、集合框架的概述
 * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
 * 说明：此时的存储，主要指内存层面的存储，不涉及到持久化的存储（.txt,.jpg，数据库中的存储）
 *
 * 2.1数组在存储多个数据方面的特点：
 *      》一旦初始化之后，其长度就确定了
 *      》数组一旦定义好了，其元素的类型也确定了。我们只能操作指定类型的数据了。比如String [] arr;
 * 2.2 数组在存储多个数据方面的缺点
 *      》一旦初始化之后，其长度就不可修改
 *      》数组中提供的方法非常有限，对于添加、删除插入数据等操作，非常不方便，同时效率不高。
 *      》获取数组中的实际元素的个数的需求，数组没有现成的属性或方法可用
 *      》数组存储数据的特点：有序、可重复。对于无序、不可重复的需求不能满足。
 *
 *二、集合框架
 *  Collection接口：单列集合，用来存储一个一个的对象
 *      子接口List：存储有序的、可重复的数据    “动态”数组
 *              ArrayList
 *              LinkedList
 *              Vector
 *
 *
 *      子接口Set：存储无序的、不可重复的数据
 *              HashSet
 *                  LinkedHashSet
 *              TreeSet
 *
 *  Map接口：双列集合，用来存储一对（key-value）一对的数据   y=f(x)
 *      HashMap
 *      LinkedHashMap
 *      TreeMap
 *      Hashtable
 *      Properties
 *
 *三、Collection接口中的方法
 *
 *Iterator迭代器（获取数据）
 * @author orz
 */
public class CollectionTest {

    /**
     *三、Collection接口中的方法
     * 1.add(Object e);
     *
     *
     */

    @Test
    public void test1()
    {

        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合当中
        coll.add("AA");
        coll.add(123);
        coll.add(new Date());

        //size()：获取添加的元素的个数
        System.out.println(coll.size());

        //addAll(Collection c):将c集合中的元素添加到当前集合中
        Collection coll2=new ArrayList();
        coll2.addAll(coll);
        System.out.println();
        System.out.println(coll2.size());

        //clear():清空集合元素
        coll2.clear();
        System.out.println();
        System.out.println(coll2.isEmpty());

        //isEmpty():判断当前集合是否为空
        Collection coll3=new ArrayList();
        System.out.println();
        System.out.println(coll3.isEmpty());

        //contains(Object obj):判断当前集合中是否包含obj
        System.out.println();
        boolean contains = coll.contains("AA");
        System.out.println(contains);


        Collection coll4=new ArrayList();
        coll4.add(123);
        coll4.add("tom");
        coll4.add(new String("Cat"));
        Person p=new Person(23,"TOM");
        coll4.add(p);


        //contains(Object obj)调用的是equals
        System.out.println();
        System.out.println(coll4.contains(new String("Cat")));
        //false -->true   考虑重写Person的equals方法
        System.out.println(coll4.contains(new Person(23, "TOM")));


        //containsAll(Collection c):判断形参c中所有元素是否都存在于当前集合中
        System.out.println();
        coll2.addAll(coll);
        System.out.println(coll2.containsAll(coll));


        //remove():移除某一个数据（也需要重写类中的equals方法）
        System.out.println();
        System.out.println(coll);
        coll.remove(123);
        System.out.println(coll);

        //removeAll(Collection c):从当前集合中移除c中所有元素（差集）
        System.out.println();
        System.out.println(coll);
        System.out.println(coll2);
        coll2.removeAll(coll);
        System.out.println(coll2);

        //retainAll(Collection c):获取当前结合与c集合的交集，并返回结果给当前集合
        Collection coll5=new ArrayList();
        coll5.addAll(coll2);
        coll5.add("789");
        System.out.println();
        System.out.println(coll5);
        System.out.println(coll2);
        coll5.retainAll(coll2);
        System.out.println(coll5);


        //equals(Object obj):判断当前集合和形参集合的元素是否都相同
        Collection coll6=new ArrayList();
        coll6.add("789");
        coll6.add(123);
        Collection coll7=new ArrayList();
        coll7.add("789");
        coll7.add(123);
        System.out.println();
        System.out.println(coll6.equals(coll7));
        Collection coll8=new ArrayList();
        coll8.add(123);
        coll8.add("789");
        //false；ArrayList是有序的
        System.out.println(coll6.equals(coll8));


        //hashcode():放回当前对象的hash值，自定义对象需要重写hashcode()方法
        System.out.println();
        System.out.println(coll8.hashCode());


        //toArray()：集合  --->数组

        System.out.println();
        Object[] obj=coll8.toArray();
        for(Object arr:obj)
        {
            System.out.println(arr);
        }

        // Arrays.asList(T... a):数组 -->集合
        System.out.println();
        List<String> list = Arrays.asList(new String[]{"AA","BB"});
        System.out.println(list);

        //错误写法
        List<int[]> list1 = Arrays.asList(new int[]{123, 334});
        System.out.println(list1);
        //正确
        List<Integer> list2 = Arrays.asList(13, 78);
        System.out.println(list2);
        //或者
        List<Integer> list3 = Arrays.asList(new Integer[]{123, 78});
        System.out.println(list3);


        //iterator():返回Iterator接口的实例，用于遍历集合元素
        //hasNext();
        //next();
        System.out.println();
        Iterator iterator = coll8.iterator();
        System.out.println(coll8);
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

        iterator=coll8.iterator();
        //迭代器Iterator中的remove()，可以在遍历时删除集合中元素。不同于集合中直接调用remove();
        //如果未调用next（）或者上一次调用next（）方法之后已经调用了remove（）方法，再次调用remove（）都会报异常
        while (iterator.hasNext())
        {
            Object obj2=iterator.next();
            //删除集合中的“789”
            if("789".equals(obj2))
            {
                iterator.remove();
            }
        }
        iterator=coll8.iterator();
        System.out.println();
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }


    /**
     * foreach循环
     * 增强for循环遍历集合或数组
     * 内部仍然调用迭代器
     */
    @Test
    public void test2()
    {
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合当中
        coll.add("AA");
        coll.add(123);
        coll.add(new Person(21,"tom"));
        coll.add(new Date());


        //for(集合中元素类型  自定义变量名:集合对象)
//        {
//            //......
//        }
        for (Object obj:coll)
        {
            System.out.println(obj);
        }

        //遍历数组

        int [] arr=new int[]{1,2,3,4,5,6,7,8,9};
        for (int i:arr)
        {
            System.out.println(i);
        }


    }


}

 

import java.util.Objects;

public class Person implements Comparable{

    private int age;
    private String name;

    public Person() {
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    //按照姓名从小到大排序,年龄从小到大

   @Override
   public int compareTo(Object o)
   {
       if(o instanceof Person)
       {
           Person person=(Person)o;
          // return this.name.compareTo(person.name);
           int compare=this.name.compareTo(person.name);
           if(compare!=0)
           {
               return compare;
           }
           else
           {
               return Integer.compare(this.age,person.age);
           }

       }
       else
       {
           throw new RuntimeException("输入的类型不匹配");
       }
   }
}