集合常用方法

Array List集合

   /**
     * 快捷键
     * 对象.for  ->增强for循环
     * 对象.for i ->普通for循环
     */
    public static void main(String[] args) {
        ArrayList list = new ArrayList(3);//初始容量为3 ，默认初始容量 10
        //ArrayList内部其实就是一个Object类型的数组
        list.add("a");
        list.add("b");
        list.add("c");
        //内部封装了扩容逻辑，每次扩大1.5倍（向下取整，舍弃小数点后）
        //扩容之后将旧数组数据迁移到新数组，在舍弃就数组，向新数组当中添加数据
        list.add("d");
        list.add("e");
        //list.toString()，toString可以省略
        System.out.println(list);
​
        //增强for循环遍历list集合
        for (Object o : list) {
            System.out.println(o);
        }
        /**
         * 泛型
         */
//        ArrayList list1 = new ArrayList(); //Object
//        list1.add(1); //int-->Integer-->Object
//        list1.add(2);
//        int sum =0;
//        for(Object e:list1){
//            //object类型没有加法,可以强转，也可以利用泛型
//            sum +=(int)e;
//        }
//        System.out.println(sum);
        ArrayList<Integer> list1 = new ArrayList<Integer>();
       //<>尖括号里面只能写引用数据类型，生命时前面已经写了<***>后面可以省略
        //确定泛型类型之后，当前集合只能存放这一类型的数据，不能添加其他类型的数据
        list1.add(1);
        list1.add(2);
        int sum =0;
        for(int i :list1){
            sum += i;
        }
        System.out.println(sum);
    }
​
​
    private static void test1() {
        //数组不能自动扩容
        String[] arr0 = new String[]{"a", "b", "c"};// 大小3
        String[] arr1 = new String[5];
​
        //for循环便利
        for (int i = 0; i < arr0.length; i++) {
            arr1[i] = arr0[i];
            System.out.println(arr0[i]);
        }
        arr1[3] = "e";
        arr1[4] = "d";
        //Arrays封装方法，toString：将数组内容拼接成一个字符串
        System.out.println(Arrays.toString(arr1));
    }

List 集合

 //ArrayList对象可以向上转型为List对象
        List<Integer> list1 = new ArrayList<>();
        //添加数据比较麻烦，需要一个一个添加
        list1.add(1);
        list1.add(2);
        list1.add(3);
        System.out.println(list1);
​
        //一次添加多个数据
        //List.of()方法 jdk1.8之后出现，jdk1.9才能运行
        //List.of()生成的集合叫做不可变的集合，一旦确定之后不允许添加修改等
//        List<Integer> list = List.of(1,2,3,4);
​
        List<Integer> list2 = new ArrayList<>();
        list2.addAll(list1); //list2 = list1
        System.out.println(list2);

Map 集合

1.key -- value ：键值对（entry）， key要唯一 映射关系

2.俩个泛型，分别用来限制key和value的类型

3.map.of()创建的是不可变的Map，new HashMap()创建的是可变的Map集合

4.map 的增删改查操作

5.map 的遍历

 public static String find(String key){
//        Map<String,Object> map =new map.of(
//                "white","小白",
//                "black","小黑"
//        );
        Map<String,String> map = new HashMap<>();
        //新增
        map.put("white","小白");
        map.put("black","小黑"); //key在map中不存在就是新增
        //修改
        map.put("black","确实黑"); //key在map中存在就是修改
        //删除
        map.remove("black");//根据key删除
        //查询
        map.get("black");//根据key查询
​
        //map的遍历
        map.entrySet();//获取所有键值对集合，可以用增强for循环遍历
        for (Map.Entry<String, String> str : map.entrySet()) {
            System.out.println(str);
            System.out.println("key " + str.getKey() + " value " + str.getValue());
        }
        return map.get(key);
    }
​
    public static void main(String[] args) {
        System.out.println(find("black"));
    }