Java集合框架

集合的定义

1. 定义:集合与数组类似，只不过集合中的数据量可以动态的变化。

   1. List集合:存放的数据可以重复，并且有顺序
   2. Set集合:存放数据无序不可重复
   3. Map集合:双列型，存放数据无序，key不可以重复，value 可以重复
   4. List Set 为单列集合 Map 为双列集合；

   

List

1. List集合:存放的数据可以重复，并且有顺序

ArrayList

 ArrayList：底层是Object数组；（查询快，增删慢）

List aList = new ArrayList(); //声明List 集合
.add(数据)     添加
.get(下标)     提取
.remove(下标/"内容")  删除 //使用remove删除数据需要集合指定泛型
.clear()             清除集合内所有的数据
.set(下标,"数据")      修改  // 第一个填下标，第二个填修改的数据
.toArray()          集合转数组
.size()              集合的长度

//查询/遍历
	//List 集合的三种遍历方法
       List aList = new ArrayList();
        aList.add(true);
        aList.add('好');
        aList.add(124);
        aList.add(3.14F);

		//提取下标输出
        Object o1 = aList.get(2);
        System.out.println(o1);

        //传统for循环遍历List集合
        for (int i=0; i<aList.size();i++){
            System.out.println(aList.get(i));
        }
        System.out.println("-------------------");


        //高级for循环遍历List集合
        for (数据类型 变量名: 数组/集合){
            System.out.println(temp);
        }
        
        for ( Object temp: aList){
            System.out.println(temp);
        }

        System.out.println("------------------");
       
       //lambda表达式 遍历List集合   forEach关键字
        aList.forEach(temp->{
            System.out.println(temp);
        });
        

//删除  remove   clear  关键字

List<String> aList = new ArrayList<String>();
        aList.add("李四");
        aList.add("李2");
        aList.add("李3");
        
        //删除下标为1的数据
        aList.remove(1);
        
        //清空集合所有的数据 
        aList.clear();
        
        
        
        aList.forEach(temp->{
            System.out.println(temp);
        });

//修改  set 关键字
  List<String> aList = new ArrayList<String>();
        aList.add("李四");
        aList.add("李2");
        aList.add("李3");

   
        //修改
        aList.set(0,"王五");


        aList.forEach(temp->{
            System.out.println(temp);
        });

泛型

 List<数据类型>//指定了数据类型，只能存放该数据类型的数据，存放其他的数据类型的数据报错
 			//不能是基本数据类型，得输入包装类
   
 List<String> aList = new ArrayList<String>();
        aList.add("李四");

LinkeList

1.LinkeList：底层是链表。（增删快，查询慢）
	
//	集合转数组
 List<String> aList = new LinkedList<String>();
        aList.add("李四");
        aList.add("李2");
        aList.add("李3");

        Object[] objects = aList.toArray(); //转数组不允许强转

Set

1. Set集合:存放数据无序不可重复
2. Set集合 没有需改 //如果要修改的话先删除，在添加
3. Set集合 查询只有全部遍历 ，没有单个查询
4. Set集合 调用的方法基本和List 集合一样 只是没有 .set 和 .get
5. HashSet 底层是哈希码 没有下标
6. TreeSet 是二叉树。 不可重复，但有序（对于实现了 Comparable ， Comparator接口类型）自带排序 但无法对中文进行排序。

HashSet

1. HashSet 底层是哈希码 没有下标

 //判断Set集合中指定元素是否存在   contains 关键件字
 boolean flag = aSet.contains(内容);
 System. out. println("flag-"+flag);

TreeSet

1. TreeSet 是二叉树。不可重复，但有序（对于实现了 Comparable ， Comparator接口类型）自带排序，但无法对中文进行排序。
2. 同HashSet 方法；

Map

1. Map集合:双列型，存放数据无序，key不可以重复，value 可以重复
2. Map没有修改,修改通过添加实现（直接覆盖旧数据）
3. HashMap底层是哈希表。key不可以重复，value可以重复。无序
4. TreeMap:底层是二叉树。key不可以重复，value 可以重复。

.put(1,"java入门")  // 添加数据；
.get(key);         //查询单个数据
.remove(下标/"内容")  删除 //使用remove删除数据需要集合指定泛型
.clear()             清除集合内所有的数据

HashMap

1.HashMap底层是哈希表。key不可以重复，value可以重复。无序

   //声明Map集合
  Map<Integer,String> bookMap = new HashMap<>();
  
        //添加数据
        bookMap.put(1,"java入门");
        bookMap.put(2,"java基础");
        bookMap.put(3,"java流程");
  
       //通过Key查询value
        String s = bookMap.get(1);
        System.out.println(s);
  
      //遍历Map集合
        bookMap.forEach((k,v)->{
            System.out.println(k+"="+v);
        });
        
      //直接打印Map集合(可以直接打印，是因为Hashtap;源码中覆盖了toString方法)
        System.out.println(bookMap);
        
     //修改 : Map没有修改,修改通过添加实现（直接覆盖旧数据）
        bookMap.put(2,"java");
        
        
        
  
  

TreeMap

1，TreeMap:底层是二叉树。key不可以重复，value 可以重复。可以根据key进行排序(一般key的类型实现了comparable."comparator接口)
2，TreeMap 的方法和HashMap一样

案例

 //案例  输入5位学员的成绩 取出里面的最高分和最低分

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5位学员的成绩");
        List<Float> list = new ArrayList<>();
        for (int i= 1;i<=5;i++) {
            Float scr1 = sc.nextFloat();
            list.add(scr1);
        }

        //Collections 集合的一个工具类   sort排序
        Collections.sort(list);
        
        Float max = list.get(list.size()-1);
        Float min = list.get(0);
        
        System.out.println("max="+max);
        System.out.println("min="+min);
    }

       //案例  输入5位学员的成绩 取出平均值
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5位学员的成绩");
        Float sum = 0F;
        for (int i= 1;i<=5;i++) {
            Float scr1 = sc.nextFloat();
            sum+=scr1;

        }

        System.out.println("sum="+sum/5);

    }

        //案例  输入5位学员的成绩 排序

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5位学员的成绩");
        List<Float> list = new ArrayList<>();
        for (int i= 1;i<=5;i++) {
            Float scr1 = sc.nextFloat();
            list.add(scr1);
        }

        //Collections 集合的一个工具类  sort 排序
        Collections.sort(list);

        list.forEach(temp->{
            System.out.println(temp);
        });

         //案例 字符 逆向输出
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5位字符串");
        List<String> list = new ArrayList<>();
        for (int i= 1;i<=5;i++) {
            String scr = sc.next();
            list.add(scr);
        }
        System.out.print("原字符序列:");

        list.forEach(temp->{
            System.out.print(temp+"\t");

        });
        System.out.println();
        //Collections 集合的一个工具类  sort 排序  升序；
        Collections.sort(list);
        System.out.print("升序排序后:");
        list.forEach(temp->{
            System.out.print(temp+"\t");
        });
        
        System.out.println();
        
        System.out.print("逆向排序后:");// 方法1；
        for(int j = list.size()-1; j>=0 ;j--){
            System.out.print(list.get(j) +"\t");
        }
        //reverse 关键字 降序；
        Collections.reverse(list);
        System.out.print("逆向排序后:"); //方法二；
        list.forEach(temp->{
            System.out.print(temp+"\t");
        });