集合笔记

list接口

定义： public interface Listextends Collection

所有内容允许重复

ArrayList (最常用)

    public static void main(String[] args) {
        //ArrayList : 使用的是数组结构,对于增加删除慢，查找快
        ArrayList<Integer> element = new ArrayList<>(100);
        //初始容量为零
        ArrayList<Integer> element1 = new ArrayList<>();
        //添加算法返回值只为true
        element.add(1);
        element.add(2);
        element.add(3);
        element.add(4);
        element.add(5);
        //get 输出制定下标的值
        System.out.println(element.get(0));
        //indexOf 查找指定对象的位置输出其下标 查找失败返回-1；
        System.out.println(element.indexOf(5));
        //删除指定下标的数
        element.remove(0);
        //修改制定下标的数
        element.set(3,3);
        System.out.println(element.get(0));
        System.out.println(element.get(1));
        System.out.println(element.get(3));
        System.out.println(element.indexOf(5));

    }     

1
4
2
3
3
-1

LinkList 双向列表

Vector

 public static void main(String[] args) {
        //Vector : 使用的是数组结构，增删慢，查找快
        Vector<Integer> element = new Vector<>();
        //添加数组元素
        element.add(111);
        element.add(234);
        element.add(456);
        element.add(789);
        //输出
        System.out.println(element.get(1));
        System.out.println(element.indexOf(234));
        //删去指定下标对应的元素
        element.remove(1);
        //向指定下标添加元素，替换当前元素
        element.set(1,456456);
        System.out.println(element.get(0));
        System.out.println(element.get(1));
        System.out.println(element.indexOf(234));
        System.out.println(element.indexOf(456456));
    }

LinkedList

很少使用作为了解

    public static void main(String[] args) {
        //LinkList 使用的是双向链表结构，增删快，查找慢
        //add
        //remove
        //get
        LinkedList<Integer> element = new LinkedList<>();
//        element.add(123);
//        element.add(234);
//        Integer i = element.removeFirst();
//        System.out.println(i);
         //压栈
        element.push(100);
        element.push(200);

        //弹栈
        Integer i = element.pop();
        System.out.println(i);
    }

itetator

    public static void main(String[] args) {
        ArrayList<Integer> element = new ArrayList<>();
        element.add(1);
        element.add(2);
        element.add(3);
        element.add(4);
        element.add(5);
        ListIterator<Integer> iterator = element.listIterator();
        iterator.add(100);
        iterator.next();
        iterator.next();
        iterator.set(200);
        System.out.println(element.size());

        iterator.previous();
        iterator.previous();
        iterator.previous();
       while(iterator.hasNext()){
           System.out.println(iterator.next());
       }
    }

forEach

//forEach : 增强For循环，最早出现在c
    //用于迭代数组 或 集合
    //语法：
    //for（数据类型 变量名:集合或数组名）{}
    public static void main(String[] args) {
        int[] arr = {6, 5, 4, 3, 2, 1};
        for (int data : arr) {
            System.out.println(data);
        }
        System.out.println("----------------------");

        ArrayList<String> element = new ArrayList<>();
        element.add("白日依山尽");
        element.add("黄河入海流");
        element.add("欲穷千里目");
        element.add("更上一层楼"); 
        for (String s:element){
            System.out.println(s);
        }
    }

6
5
4
3
2
1
----------------------
白日依山尽
黄河入海流
欲穷千里目
更上一层楼

set

不包含重复单值的集合

    //HashSet:散列存放(哈希表在学习HashMap时有涉及)
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        boolean flag1 = set.add("白日依山尽");
        set.add("白日依山尽");
        set.add("黄河入海流");
        set.add("欲穷千里目");
        set.add("更上一层楼");
        boolean flag2 = set.add("白日依山尽");
        System.out.println(flag1+""+flag2);
        for (String s:set){
            System.out.println(s);
        }
        /*Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }*/
    }
}

TreeSet

package Demo4;


import java.util.TreeSet;

public class Demo2 {
    public static void main(String[] args) {
        TreeSet<Person> element = new TreeSet<>();
        Person p1 =new Person("张三",20);
        Person p2 =new Person("柳威",22);
        Person p3 =new Person("李四",22);//不能存储相同的数据
        element.add(p1);
        element.add(p2);
        element.add(p3);
        for(Person p:element){
            System.out.println(p);
        }
    }
    
    static  class Person implements Comparable <Person>{
        private String  name;
        private int age;


        @Override
        public int compareTo(Person o) {
            // this 与 o 比较
            //返回的数据: 负数this小/零一样大/正数this大
            if (this.age>o.age){
                return 1;
            }else if (this.age == o.age){
                return 0;
            }
            return -1;
        }

        public Person() {
        }

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

    }
}

List 和 Set 的区别ArrayList 和 LinkedList 的区别是什么？

map

public static void main(String[] args) {
        HashMap<String,String> element = new HashMap<>();
        element.put("1","白日依山尽");
        element.put("2","黄河入海流");
        element.put("3","欲穷千里目");
        element.put("4","更上一层楼");
        Set<String> set = element.keySet();
        for (String s:set){
            System.out.println(s+"+"+element.get(s));
        }
        Collection<String > c = element.keySet();
        for (String a:c){
            System.out.println(a+element.get(a));
        }
    }

HashMap、Hasjtable、ConcurrentHashMap

都是数据的容器（存取删）

多线程、线程安全与否

HashMap : 线程不安全，效率高 不保证存储顺序 （TreeMap 会自动进行排序）

Hashtbable: 线程安全，效率低

ConcurrentHashMap: 采用分段锁机制，保证线程安全，效率又比较高

public class Demo {
    public static void main(String[] args) {
        HashMap<Book,String> element = new HashMap<>();
        Book b1 = new Book("三国演义","打仗");
        element.put(b1,"第一本书");
        Book b2 = new Book("水浒传","梁山好汉");
        element.put(b2,"第二本书");
        System.out.println(element.get(b1));
        b1.setName("西游记");
        System.out.println(element.get(b1));

        Book b3 =new Book("三国演义","打仗");
        System.out.println(element.get(b3));
        //键值不要随便改
    }

    static class Book{
        private String name;
        private  String info;

        public Book(String name, String info) {
            this.name = name;
            this.info = info;
        }

        public Book() {
        }

        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", info='" + info + '\'' +
                    '}';
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getInfo() {
            return info;
        }

        public void setInfo(String info) {
            this.info = info;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Book book = (Book) o;
            return Objects.equals(name, book.name) &&
                    Objects.equals(info, book.info);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, info);
        }
    }
    
第一本书
null
null

jdk9新特性

public class Demo {
    //JDK 9 集合新特性
    public static void main(String[] args) {
        List<String> list = List.of("白日依山尽","黄河入海流");
        for (String a:list){
            System.out.println(a);
        }
        Set<String> set = Set.of("欲穷千里目","更上一层楼");
        for (String b:set){
            System.out.println(b);
        }
        Map<String,String> map = Map.of("1","床前明月光","2","疑似地上霜");
        Set<String> keySet = map.keySet();
        for (String c:keySet){
            System.out.println(c+"->"+map.get(c));
        }
    }
}

白日依山尽
黄河入海流
更上一层楼
欲穷千里目
1->床前明月光
2->疑似地上霜