Java基础-集合1

集合

• 数组的长度是一旦确定就不能改动，数组元素类型必需一致
• 集合长度不定，集合元素类型不要求一样，只能放引用类型

1.1.集合

1.1.1.集合分类

1.1.1.1. Collection 存放单值

• List 有序可以重复

  ArrayList 底层是数组（一块连续的内存地址），查找和修改比较快，新增（指定索引位置插入）和删除比较 慢；

  LinkedList 底层是双向链表，查找和修改相对较慢，新增和删除相对比较快；

  Vector，底层也是数组，和ArrayList一致；内部方法加了线程同步，性能较低；

• Set 无序不可重复

  HashSet 底层是HashMap 在进行比较两个对象是否相等的时候，使用equals进行比较，还会计 算对象的hash值

  LinkedHashSet是HashSet子类，底层是LinkedHashMap;元素的插入顺序和遍历顺序一致；

  TreeSet底层用到了红黑树，集合元素会进行排序；要求插入的类型实现Comparable接口，或者 提供一个Comparator的实现类

list中常用方法1

public static void main(String[] args) {
    //父类引用指向子类对象
        List arrayList = new ArrayList();
        // isEmpty判断list为空吗
        System.out.println("是否为空" + arrayList.isEmpty());
        //add 是追加
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        // add指定索引位置添加的时候，index不能超集合元素个数
        arrayList.add(3, "4");
        //把集合元素直接打印出来
        System.out.println(arrayList);
        //获取list大小
        int size = arrayList.size();
        System.out.println(size);
        // contains是否包含指定的集合元素
        System.out.println("是否包含：" + arrayList.contains("456"));
        // toArray把list转成数组
       /* Object[] objects = arrayList.toArray();
        System.out.println(Arrays.toString(objects));*/
       //移除集合元素，指定索引删除或者指定元素删除
        arrayList.remove(3);
        arrayList.remove("4");
        System.out.println(arrayList);
    }

list 常用方法2

public static void main(String[] args) {
        List arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        List arrayList2 = new ArrayList();
        arrayList2.add("1");
        arrayList2.add("2");
        //集合是否包含另一个集合（集合中每个集合元素都有包含在内）
        boolean b = arrayList.containsAll(arrayList2);
        System.out.println(b);
        // 添加集合（每个集合元素添加进去）
        arrayList.addAll(arrayList2);
        System.out.println(arrayList);
        // 按指定的集合进行删除
//        arrayList.removeAll(arrayList2);
        System.out.println(arrayList);
        //清空集合元素
//        arrayList.clear();
        System.out.println(arrayList);
        //索引从0开始
        System.out.println(arrayList.get(2));
        // 指定索引修改集合元素
        arrayList.set(2, "abc");
        System.out.println(arrayList);
        System.out.println("指定元素首次出现的索引位置：" + arrayList.indexOf("1"));
        System.out.println("指定元素最后一次出现的索引位置：" + arrayList.lastIndexOf("1"));
        // 截取子集合，起始索引包含，尾部索引不包含
        List list = arrayList.subList(2, arrayList.size());
        System.out.println(list);

set 常用方法

public static void main(String[] args) {
        HashSet<String> strings = new HashSet<>();
        String str1 = new String("abc");
        String str2 = new String("abc");
        //注意点：abc只会插入一次
        strings.add(str1);
        strings.add(str2);
        // str1.equals(str2)
        System.out.println(strings);
        System.out.println(strings.size());
        Object[] objects = strings.toArray();
        // set转数组
        System.out.println(Arrays.toString(objects));
    }

list/set的遍历方式

1，对list遍历

public static void main(String[] args) {
        ArrayList<String> stArr = new ArrayList<>();
        stArr.add("aa");
        stArr.add("bb");
        stArr.add("cc");
        //1,普遍for循环
        for (int i = 0; i < stArr.size(); i++) {
            System.out.println(stArr.get(i));
        }
        //2,增强for循环
        for (String s : stArr) {
            System.out.println(s);
        }
        System.out.println("==============");
        //3,使用迭代器遍历
        Iterator<String> iterator = stArr.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("++++++++++++++++");
        //4，使用forEach遍历
        stArr.forEach(s -> {
            System.out.println(s);
        });
    }

2，对set进行遍历

public static void main(String[] args) {
        HashSet<String> strings = new HashSet<>();
        strings.add("a");
        strings.add("b");
        strings.add("c");
        //1,增强for循环
        for (String string : strings) {
            System.out.println(string);
        }
        //2,使用迭代器遍历
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //3，
        strings.forEach(str -> {
            System.out.println(str);
        });
    }

1.1.1.2. Map 存放成对的值

1.2.匿名内部类和lambda表达式

1，匿名内部类

如果一个接口上面 @FunctionalInterface表示这是一个功能性接口，里面的抽象方法只有一个；

匿名内部类的使用：匿名内部类，一次性的，只能使用一次，做不到代码重用

public static void main(String[] args) {
        // 匿名内部类，一次性的，只能使用一次，做不到代码重用
        TreeSet<Student> strings = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        strings.add(new Student("anne"));
        strings.add(new Student("jerry"));
        strings.add(new Student("anne"));
        System.out.println(strings);
    }

使用

public static void main(String[] args) {
        // 匿名内部类，一次性的，只能使用一次，做不到代码重用
        TreeSet<Student> strings2 = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        //lambda表达式，1.8之后出现的；接口中只有一个抽象方法的时候可以使用
        TreeSet<Student> strings = new TreeSet<>((a, b) -> {
            return a.getName().compareTo(b.getName());
        });
        strings.add(new Student("anne"));
        strings.add(new Student("jerry"));
        strings.add(new Student("anne"));
        System.out.println(strings);
    }