集合----Arraylist

数组：存储多个对象
int[] score = {1,2,3};
int[] score = new int[10];
弊端：数组的长度不可变优点：内容可变
实际开发中需要一个能够随时改变的数组 -> 集合Collection
Collection抽象接口
定义集合的相关操作
List接口列表数组特点：有序可重复
Set"集合" 特点:无序不重复
1.集合框架

引入集合的好处在于相比数组，集合的长度可变，能很好的适应元素数量的动态变化。

集合框架都包含三大块内容：
1）接口：即表示集合的抽象数据类型
2）实现：即集合框架中接口的具体实现
3）方法：实现集合接口对象身上完成某种有用的计算的方法，如查找，排序等。java提供了进行集合操作的工具类Collections。

常用的集合接口和实现：

image.png

集合的三大类接口：
collection（其有三个子类：List,Queue,set）
Map,Iterator(迭代器，专门为集合接口和类提供便利方法)。
(1)collection接口存贮一组不唯一（允许重复），无序的对象。
(2)Set接口存储一组唯一，不允许重复，无序的对象。
(3)List接口存储一组不唯一，允许重复，有序(以元素插入的位置来放置元素，不会重新排列)的对象。
(4)Map接口存储一组成对的键值对象，提供key键到value值得映射。Map中的key不要求有序，不允许重复，value不要求有序可以重复

Collection

集合的元素个数是可变的

添加元素

add

Collection <String>t1 = new  ArrayList();
      t1.add("Jack");
     t1.add("Nerry");
     System.out.println(t1);

addAll

ArrayList<Integer> a2 = new ArrayList<>();    
  a2.add(1);   
  a2.add(2);      
  a2.add(3);  
  a2.add(0,1);//在指定位置插⼊入      
 //将⼀一个集合⾥里里⾯面的内容添加到当前集合中        
score.addAll(a2);     
System.out.println(a2);

删除元素
remove

 //删除⼀一个对象     
   t1.remove("Jack");    
   t1.remove(0);//删除指定位置的元素 
    System.out.println(t1);

获取元素个数

size

//获取元素个数     
   System.out.println(t1.size());

是否包含⼀一个元素

contains

   //判断是否包含⼀一个元素    
    if (t1.contains("Merry")){ 
           System.out.println("有merry");   
     }else{         
  System.out.println("没有merry");    
    }

是否为空

isEmpty

//判断是否为空     
   if(t1.isEmpty()){   
         System.out.println("是空的");    
    }

集合比较

equals

 //判断两个集合是否相同(⽐比较集合⾥里里⾯面的内容）        Collection<String> t2 = new ArrayList<>();     
  t2.add("Merry");        
  t2.add("Jack");      
  t2.add("Rose");   
  t2.add("Tom");     
   if (t1.equals(t2)){         
        System.out.println("两个集合相同");    
         } else{          
        System.out.println("两个集合不不相同");   
     }

清空

clear

 //清空     
   t1.clear();   
   System.out.println(t1);

取两个集合的交集

ArrayList<Integer> a3 = new ArrayList<>();        
a3.add(1);        
a3.add(2);        
score.retainAll(a3); //取两个集合的交集

访问某个对象在集合里面的索引

ArrayList<Integer> a4 = new ArrayList<>();       
a4.add(1);        
a4.add(2);        
a4.add(2);        
a4.add(1);        
System.out.println(a4.indexOf(1));//第⼀一次出现的位置        System.out.println(a4.lastIndexOf(1));//最后⼀一次出现的位置

集合的遍历

    //使用Iterator来遍历
      //hasNext 判断是否有元素
      //next 获取下一个对象
      //remove  删除当前遍历过后的对象
       Iterator iterator = t2.iterator();
     //  指针是指到第一个的前的
     while(iterator.hasNext()){
          System.out.println(iterator.next());
     }
/**********************************************************/
      while(iterator.next()!=null){
        System.out.println(iterator.next());
       }    //错误方法
//  遍历过程会跳着走

      //2.for-each   增强for循环   快速循环
       for(String obj:t2){
           System.out.println(obj);
       }

     //3. for-i
       for(int i=0 ; i<t2.size();i++){
           System.out.println(((ArrayList<String>) t2).get(i));  
 //先将t2进行强制转换   再遍历
      }
      //遍历数组的三种方式

List接口（extends Collection）

   ```
  LinkedArrayList:
 不一定连续    （基本不连续）
  优点     增加删除 效率高   缺点  访问繁琐，效率不高
  内部使用链表实现
 Arraylist;
 连续的内存空间
 优点：访问方便  get(0)  缺点：  元素的删除、添加

包装类

包装类：基本数据类型的对象化表现

由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供包装类
//八大基本数据类型都对应着一个包装类类型
//byte short int long float double char boolean
//Byte Short Integer Long Float Double Character Boolean

包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量

将ArrayList转换为普通数组

  public static  void main(String [] args){
            // 将ArrayList转换为普通数组
            ArrayList<Integer> a = new ArrayList<>();
            a.add(1);
            a.add(2);
            a.add(2);
            a.add(1);
            System.out.println(a.indexOf(1));
            System.out.println(a.lastIndexOf(1));
            Integer [] objects = new Integer[a.size()];
            a.toArray(objects);
            for(Integer i :objects){
                System.out.println(i);
            }
            //方法2
        System.out.println("*********************");
        Object[] objects1 = a.toArray();
        for (Object i: objects1  ) {
                   System.out.println(i);
        }
    }

闭包 enclusure 把函数作为一个方法的参数

class ArrayClass{
    public void test(int[] target, Show s){
        for (int element: target){
            s.customShow(element);
        }
    }
}

//必须是接口 这个接口里面只有一个方法
interface Show{
    void customShow(int element);
}

class PXDClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

//1.使用方式: 定义一个类实现接口
//        ArrayClass ac = new ArrayClass();
//        int[] num = {1,2,3,4,5,6};
//        PXDClass pc = new PXDClass();
//        ac.test(num, pc);

        //2.使用匿名类
//        ArrayClass ac = new ArrayClass();
//        int[] num = {1,2,3,4,5,6};
//        ac.test(num, new Show() {
//            @Override
//            public void customShow(int element) {
//                System.out.println(element);
//            }
//        });

        //3. 使用Lambda表达式
        //如果参数是一个接口类对象，且接口里面只有一个方法
        //可以省略方法名
//        ArrayClass ac = new ArrayClass();
////        int[] num = {1,2,3,4,5,6};
////        ac.test(num, (int element) -> {
////            System.out.println(element);
////        });