集合Collection

集合Collection

1、数组与集合

/*

1．集合与数组存储数据概述:
集合、数组都是对多个数据进行存储操作的结构，简称ava容器
说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中)

2．数组存储的特点:
>一旦初始化以后，其长度就确定了。
〉数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。*
比如: String[]arr;int[]arr1;object[] arr2;


3．数组存储的弊端:
>一旦初始化以后，其长度就不可修改。
〉数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
〉获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
〉数组存储数据的特点:序、可重复。对于无序、不可重复的需求，不能满足。


4．集合存储的优点:
解决数组存储数据方面的弊端。

 */

2、Collection接口

1.collection集合框架结构

/*
1.单列集合框架结构
collection接口:单列集台用来存储一个一个的对象
----List接口:存储序的、可重复的数据。-->“动态”数组
----ArrayList、LinkedList、Vector
----Set接口:存储无序的、不可重复的数据——>高中讲的"集合”
----HashSet、 LinkedHashSet、 TreeSet
*/

2.collection接口常用方法:

1.常用方法一：

/*
常用方法一：
    1.add()    增加
    2.addAll()     增加所有
    3.size()     大小
    4.clear()     清理
    5.isEmpty()   是否为空
   */


//collection接口常用方法一:
    @Test
    public  void collect1(){
   
        Collection collection=new ArrayList ();

        //add()    增加
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");


        //addAll()     增加所有
        Collection collection1=new ArrayList ();
        collection1.add (456);
        collection.addAll (collection1);

        //size()     大小
        System.out.println (collection.size ());   //4

        //clear()     清理
        collection1.clear ();


        //isEmpty()   是否为空
        System.out.println (collection.isEmpty ());  // false
        System.out.println (collection1.isEmpty ());  //true
    }

2.常用方法二：

//collection接口常用方法二:
/*
1.contains(0bject obj):
判断当前集合中是否包含obj我们在判断时会调用obi对象所在类的equals().

2.containsAlL(collection coll):
判断形参coll1中的所有元素是否都存在于当前集合中e
*/
@Test
    public void collect2(){
   
Collection collect=new ArrayList ();
collect.add(123);
collect.add("FF");
collect.add(new Date ());

//1.contains(0bject obj):
// 判断当前集合中是否包含obj我们在判断时会调用obi对象所在类的equals().
    System.out.println (collect.contains (123));//true

    //2.containsAlL(collection coll):
    // 判断形参coll1中的所有元素是否都存在于当前集合中e
    Collection collect2=new ArrayList ();
    collect2.add("FF");
    System.out.println (collect.containsAll (collect2));//true

}

3.常用方法三：

 //collection接口常用方法三:
/*
1.remove(Object o)  删除
2.removeAll(Collection collection)   两个集合的差集
3.retainAll(Collection collection)  两个集合的交集
4.equals(Object o)  判断是否相等，存在有序
*/
    @Test
    public  void test3(){
   
        Collection collection=new ArrayList ();
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");
        collection.add(456);

        //remove(Object o)  删除
        collection.remove (123);
        System.out.println (collection);

        //removeAll(Collection collection)   两个集合的差集
        Collection collect1= Arrays.asList ("AA",456);
        collection.removeAll (collect1);
        System.out.println (collection);

    }
    @Test
    public void test44(){
   
        Collection collection=new ArrayList ();
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");
        collection.add(456);
        Collection collect1= Arrays.asList ("AA",456);

        //retainAll(Collection collection)  两个集合的交集
        collection.retainAll (collect1);
        System.out.println (collection);

        //equals(Object o)  判断是否相等，存在有序
        System.out.println (collection.equals (collect1));
    }

4.常用方法四：

  //collection接口常用方法四:
/*
1.hashCode() 返回当前对象的哈希值
2.toArray()    集合——>数组
3.Arrays.asList() 数组——>集合
*/
    @Test
    public  void test4(){
   
        Collection collection=new ArrayList ();
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");
        collection.add(456);

        //hashCode() 返回当前对象的哈希值
        System.out.println (collection.hashCode ());

        //toArray()    集合——>数组
        Object[] objects = collection.toArray ();
        for(int i=0;i<objects.length;i++){
   
            System.out.println (objects[i]);
        }


        //Arrays.asList() 数组——>集合
        List<String> strings = Arrays.asList (new String []{
   "YY", "FF"});
        System.out.println (strings);

        //注意：
//         List<int[]> list = Arrays.asList (new int[]{123, 111});// 输出为[[I@5891e32e]
//        System.out.println (list.size ());//此时默认长度为1
        List<Integer> list1 = Arrays.asList (new Integer[]{
   123, 234});//输出为[123, 234]
        System.out.println (list1);
        System.out.println (list1.size ());//此时默认长度为2
    }

3、Iterator接口遍历集合元素

/*
集合元素的遍历操作：迭代器Iterator接口
1.内部的方法: 
      hasNext()
      next()
2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
默认游标都在集合的第一个元素之前。
3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

 */
@Test
    public void test(){
   
        Collection collection=new ArrayList ();
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");
        collection.add(456);

       java.util.Iterator iterator = collection.iterator ();

        //遍历此集合中的所有元素————>三选一，不能同时运行
        //next () 遍历集合中的元素
        //方式一：若要遍历集合中的所有的，则需要重复操作   不推荐
        System.out.println (iterator.next ());//AA
        System.out.println (iterator.next ());//123
        System.out.println (iterator.next ());//BB
        System.out.println (iterator.next ());//456
        System.out.println ("************");

        //方式二：   for循环+iterator.next ()   不推荐
        for(int i=0;i<collection.size ();i++){
   
            System.out.println (iterator.next ());
        } 
        System.out.println ("************");

        //方式三：iterator.hasNext ()+iterator.next ()  推荐
        while(iterator.hasNext ()){
   
            System.out.println (iterator.next ());
        }
        
 //错误写法一：类似于指针，不能用非空判断  NoSuchElementException
//        while(iterator.next ()!=null){
   
//            System.out.println (iterator.next ());
//        }
//
//        //错误写法二：重复输出集合中的第一个元素
// //       集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
    默认游标都在集合的第一个元素之前。
//        while(collection.iterator ().hasNext ()){
   
//            System.out.println (collection.iterator ().next ());
//        }
    }

    @Test
    public  void test5(){
   
        Collection collection=new ArrayList ();
        collection.add("AA");
        collection.add (123);
        collection.add ("BB");
        collection.add(456);

        java.util.Iterator iterator = collection.iterator ();

        while(iterator.hasNext ()){
   
                Object obj = iterator.next ();
                 if("BB".equals (obj)){
   
                  /*
                  remove()移除
                  如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，
                  再调用remove都会报ILegalStateException。
                      */
                iterator.remove ();
            }
        }
        java.util.Iterator iterator1 = collection.iterator ();
        while(iterator1.hasNext ()){
   
            System.out.println (iterator1.next ());
            }
        }
    

4、forEach循环遍历

        @Test
    public  void test6(){
   
            Collection collection=new ArrayList ();
            collection.add("AA");
            collection.add (123);
            collection.add ("BB");
            collection.add(456);

             // for (集合类型  参数名 :集合名 )
            for (Object o:collection
                 ) {
   
                System.out.println (o);
            }
            System.out.println ("**************");


            //数组的循环遍历
            // for (数组类型  参数名 :数组名 )
            String[] arr=new String[]{
   "YY","FF"};
            for (String s: arr
                 ) {
   
                System.out.println (s);
            }
            System.out.println ("************");


            //测试题：
            // forEach循环的遍历跟for循环遍历
            String[] strings=new String[]{
   "FF","FF"};
            for (String s: strings
            ) {
   
               s="YY";
            }

            for (String s: strings
            ) {
   
                //forEach循环的遍历，不改变其原本的元素，因为 s="YY"；这里的s只是参数名
                System