List类

特点：可重复,有序(次序, 有下标)

ArrayList

构造方法：

创建list对象：

public static void main(String[] args) {
     int arr[] = {1,2,3,4,5};
     List list = new ArrayList(Collections.singleton(arr));
     System.out.println(list);
 }

创建一个list对象并且把arr数组放入list中

常用方法：

常用方法：

add(int index , 元素) 在指定下标插入元素

public static void main(String[] args) {
   List list = new ArrayList();
   list.add(1);
   list.add("hello");
   System.out.println(list);
}

 

remove(int index) 删除指定下标的元素

public static void main(String[] args) {
   List list = new ArrayList();
   list.add(1);
   list.add("hello");
   list.remove(0);
   System.out.println(list);
}

 

set(int index, 元素) 修改指定下标的元素

public static void main(String[] args) {
   List list = new ArrayList();
   list.add(1);
   list.add("hello");
   list.set(1,"你好");
   System.out.println(list);
}

 

int indexOf(元素) 查找第一次出现该元素的下标

public static void main(String[] args) {
   List list = new ArrayList();
   list.add(1);
   list.add(6);
   list.add(1);
   list.add(6);
   list.add(1);
   list.add(6);
   System.out.println("6第一次出现的位置的下标为：" + list.indexOf(6));
   System.out.println(list);
}

 

Object get(int 下标) 获取指定下标的元素

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("ff");
        list.add(1);
        list.add("你好");
        list.add(1);
        list.add(6);
        System.out.println("6第一次出现的位置的下标为：" + list.get(3));
        System.out.println(list);
    }

 

boolean contains(Object c)判断集合里是否有c的存在

Object[] toArray()返回集合所有元素组成的数组

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("ff");
        list.add(1);
        list.add("你好");
        list.add(1);
        list.add(6);
        System.out.println(list.contains("你好"));
        Object arr[] = list.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

 

set集合

HashSet集合

特点: 不重复，散列存放

构造方法：

常用方法：

public static void main(String[] args) {
        Set set = new HashSet();//常见set对象
        set.add("hello");//add（）向集合里元素
        set.add("你好");
        set.add(3.14);
        System.out.println(set.contains(3.14));//contains（Object c）判断集合里是否含有c元素
        System.out.println(set.remove(3.14));//删除元素，成功true，失败false
        for (Object o : set) {
            System.out.println(o);
        }
    }

 

 

TreeSet集合

特点：不可重复，有序存放

构造方法

TreeSet可以采用两种方法实现排序：自然排序和定制排序。默认情况，TreeSet采用自然排序。

TreeSet调用调用集合元素的CompareTo()方法，根据该方法的返回值来比较元素之间的大小，然后进行“升序”排列，这种排序方式我们称之为自然排列。

自然排序

需要存储的对象所属类必须实现Comparable 接口。该接口只有一个方法public int compareTo(Object obj)，必须实现该方法。

compareTo方法的实现规则：

返回 0，表示 this == obj。//则不会添加新对象

返回正数，表示 this> obj //添加到原来对象的右边

返回负数，表示 this < obj // 添加到原来对的左边

 @Override
    public int compareTo(Student o) {
        //根据年龄升序排序
        int rs =   this.age - o.age;
        if(rs == 0 ){
            if(o == this){
                return 0;
            }else{
                return -1;
            }
        }
        return rs;
    }

定制排序

使用Comparable接口定义排序顺序有局限性：实现此接口的类只能按compareTo()定义的这一种方式排序。

如果需要更加灵活地排序，我们可以自定义(Comparator)比较器，在创建TreeSet集合对象时把我们自定义的比较器传入，则可以TreeSet会按照我们的比较器中定义的规则进行排序。

自定义比较器类，需要实现Comparator接口。Comparator接口只有一个抽象方法需要实现：public int compare(Object a, Object b);

判断规则：

返回 0，表示a == b

返回正数，表示b > b

返回负数，表示a < b

创建TreeSet集合对象时，把自定义比较器对象传入即可，TreeSet会自动按照比较器中的规则进行排序。

public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Student stu1 = (Student)o1;
                Student stu2 = (Student)o2;
                //按照年龄的降序排序
                return  stu2.getAge() - stu1.getAge() ;
            }
        });
       treeSet.add(new Student("张三",21));
        treeSet.add(new Student("李四",18));
        treeSet.add(new Student("王五",20));
        treeSet.add(new Student("李琦",19));
        System.out.println(treeSet);
    }

Map集合

Map集合的特征

1.1 通过键-值(key-value)对的形式来存储数据

1.2 Map的实现：HashMap(使用频率最高的),TreeMap,HashTable

1.3 Map中，key可以为任意类型，但这里建议使用String,value也可以是任意类型

1.4 Map里面多个value可以是不同类型

1.5 Map里面key是可以重复的,当key重复时，后存入的数据会覆盖前面的数据

1.6 Map里面，value可以重复.

1.7 Map里面的key可以为null,但是只能有一个，多个的时候，后面的会覆盖前面的

1.8 Map中value可以是null,多个value可以同时为null。

常用方法

boolean containsKey(Object key):判断是否包含指定的key

V get(Object key):根据指定的key来获取对应的value

Set<K> keySet():Map中所有key的集合

V put(K key, V value):把指定的key-value存入Map集合

int size():Map集合中key-value的长度

Collection<V> values():返回Map中所有的value的集合，不包括key

public static void main(String[] args) {
        Map map = new HashMap();
​
        //**V put(K key, V value):把指定的key-value存入Map集合**
        map.put("中国","China");
        map.put("美国","U.S.");
        map.put("日本","Japan");
​
        //boolean containsKey(Object key):判断是否包含指定的key
        System.out.println(map.containsKey("中国"));
​
        //**V get(Object key):根据指定的key来获取对应的value**
        System.out.println(map.get("日本"));
​
        //Set<K> keySet():Map中所有key的集合
        System.out.println(map.keySet());
​
        //int size():Map集合中key-value的长度
        System.out.println(map.size());
​
        //Collection<V> values():返回Map中所有的value的集合，不包
        System.out.println(map.values());
    }

 

HashMap的遍历

方法一：1.通过keySet()方法，找到所有key的集合,返回类型是一个Set;

2.通过Iterator迭代器，迭代出Set中的每一个key;

3.通过get(key)方法，根据上一步得到的key,来获取对应的value

Set keys = map.keySet();
Iterator iterator = keys.iterator();
while(iterator.hasNext()){
Object key = iterator.next();
Object val = map.get(key);
}

方法二：1.通过values()方法，获取map集合中所有的value的集合.返回值类型为Collection(该接口是List和Set的父接口,该类型下有Iiterator迭代器，可以用来迭代)

2.通过Iterator迭代器,迭代出所有的value

Collection values = map.values();
Iterator iterator = values.iterator();
while(iterator.hasNext()){
Object value = iterator.next();
}

方法三：1.通过entrySet()方法，得到一个Entry对象的集合，这里用Set来装载.

2.通过Set中的迭代器，迭代出每一个Entry对象.

3.针对每一个Entry对象，通过getKey()和getValue()方法，来分别获取到对应的key和value

Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while(iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Object key = entry.getKey();
Object value = entry.getValue();
}
​