java从头开始--集合2（Collection,Collections,Map,List,Set）

Collection接口中定义的方法

Collection接口中定义的方法是所有的集合中都具有的基本的方法.

public static void main(String[] args) {
		/*
		 * 集合中默认可以存储任意数据类型,建议使用泛型,存储同一种类型的数据
		 */
		 Collection<String> c = new ArrayList<String>();
		            c.add("abc");
		            c.add("ab");
		            c.add("c");
		            c.add("d");
		            
		            //c.clear();
		            //System.out.println(c.remove("f"));//删除指定的元素,有返回true,否则返回false
		            //System.out.println(c.contains("a"));
		            //System.out.println(c.isEmpty());
		            //有条件的删除
		           /* c.removeIf(new Predicate<String>() {
		            	public boolean test(String t) {
		            		return t.startsWith("a");//删除的过滤条件
		            	};
					});*/
		            
		            //流的方式遍历集合
		            //c.stream().forEach((a)->System.out.println(a));
		    System.out.println(c);
	}



public static void main(String[] args) {
		/*
		 * 集合中默认可以存储任意数据类型,建议使用泛型,存储同一种类型的数据
		 */
		 Collection<String> c = new ArrayList<String>();
		            c.add("abc");
		            c.add("ab");
		            c.add("c");
		            c.add("d");
		     
		      //集合转 数组
		      Object [] obj = c.toArray();
		      String [] str =  c.toArray(new String[c.size()]);       
		    
		      System.out.println(c);
		    
		    
		    //数组转集合
		     /*int [] a = {1,2,3,4};
		       Collection c1 = Arrays.asList(a);
		     
		     System.out.println(c1);*/
		      
		      test(1,2,3,4);
		    
	}
	
	/*
	 * int...a 可变长度的参数,本质是一个数组
	 * 一个参数列表中只能有一个可变长度的参数,并且只能放在参数列表的末尾
	 */
	public static void test(int a,int...b){
		System.out.println(a);
		System.out.println(Arrays.toString(b));
	}

List

可以存储重复元素

ArrayList

数组实现 查询快,增删慢(在中间)

LinkedList

链表实现 查询慢,增删快

Vector

数组实现,线程安全的

集合的迭代

Stream.forEach(lambda表达式)

for 循环

增强for

迭代器

​ iterator() 返回一个迭代器 计数器

​ listIterator()

ArrayList

实例1：

package com.ff.javaCollection.day2;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("d");
        //遍历方式1：List接口实现类的遍历，stream流
        arrayList.stream().forEach((a) -> System.out.print(a));
        System.out.println();
        
        //遍历方式2：for循环
        //要从集合中删除元素时要注意，删除后会出现元素下标和集合中大的内容不对应的情况，因此要i--，返回上一个元素在检验一次
        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).equals("a")) {
                arrayList.remove(i);
                i--;
            }
        }
        System.out.println(arrayList);
        
        //遍历方式3：增强for循环，理论上不允许删除集合中的元素
        //如果删除元素，会出现异常：java.util.ConcurrentModificationException，若要删除，只允许一次删除一个，删除完后用break终止循环
        for (String temp : arrayList) {
            if (temp.equals("a")) {
                arrayList.remove(temp);
                break;
            }
        }
        System.out.println(arrayList);
    }
}

运行结果：

实例2：

package com.ff.javaCollection.day2;

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorDemo1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("a");
        arrayList.add("c");
        arrayList.add("d");
        Iterator it = arrayList.iterator();
       // System.out.println(it);//java.util.ArrayList$Itr@15db9742
        /*迭代器1  Iterator的遍历
        hasNext()判断集合中还有没有元素
        remove()删除元素，删除后里面的游标（指针，计数器）会回退一下
         */
        while (it.hasNext()) {
            Object s = it.next();
            //去除重复元素“a"
            if (s.equals("a")) {
                it.remove();//使用迭代器中提供的remove()方法
            }
        }
        System.out.println(arrayList);
    }
}

运行结果：

实例:3：

package com.ff.javaCollection.day2;

import java.util.ArrayList;
import java.util.ListIterator;

/*迭代器2 ListIterator()
适用于List接口实现类
遍历时还可以添加元素，设置替换元素，nextIndex()元素位置
 */

public class IteratorDemo2 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("a");
        arrayList.add("c");
        arrayList.add("d");
        /*
        //从前向后遍历元素
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            //System.out.println(listIterator.next());
            //System.out.println(listIterator.nextIndex());//依次获取遍历时候的下标
            //System.out.println(listIterator.next()+":"+listIterator.nextIndex());

            System.out.println(listIterator.next());
           // listIterator.add("a");//在每个元素后加“a”
            //listIterator.set("s");//将所有元素设置为“s”
            listIterator.remove();//将全部的元素移除
        }*/
        //从后向前遍历元素
        ListIterator listIterator = arrayList.listIterator(arrayList.size());
        System.out.println(listIterator.hasPrevious());
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
        System.out.println(arrayList);
    }
}

运行结果：

linkedList

实例：

package com.ff.javaCollection.day2;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        //linkedList中提供了许多关于链表头尾的操作方法，这些方法用于模拟对列结构，栈操作等
        linkedList.addLast("a");
        linkedList.addLast("b");
        linkedList.addLast("c");
        linkedList.addLast("d");
        linkedList.addLast("e");
       // linkedList.clear();
        System.out.println(linkedList.pollFirst());//检索并删除此列中的第一个元素并输出。若此列为空，则返回null
        System.out.println(linkedList);
        System.out.println(linkedList.peekFirst());//检索但不删除此列的第一个元素，并输出。若为空，则返回null
        System.out.println(linkedList.getFirst());//得到第一个元素
        System.out.println(linkedList.removeFirst());//删除并返回第一个元素
        System.out.println(linkedList);

        linkedList.addFirst("1");
        linkedList.offerFirst("1");
        linkedList.offerLast("x");
    }
}

运行结果：

Vactor

实例：

package com.ff.colletion.day3;

/*
 * Vactor 
 * 1.底层也是数组实现的
 * 2.在创建Vactor对象时就已经创建了底层的存储数组，默认长度为10
 * 3.Vator中所有方法都是线程安全的
 */
import java.util.Vector;

public class VactorDemo {
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("a");
		v.add("a");
		v.add("a");
		System.out.println(v);
	}
}

运行结果：

Set

Set：不能存储重复元素

HashSet

实例1：

package com.ff.colletion.day3;

/*
 * set 不可以存放重复元素
 * HashSet 不可以存放重复元素，无序存储。（不是按照添加顺序排列）
 */
import java.util.HashSet;

public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> hs = new HashSet();
		hs.add("a");
		hs.add("a");
		hs.add("c");
		hs.add("d");
		hs.add("g");
		hs.add("f");
		hs.add("s");
		hs.add("x");
		System.out.println(hs);
		/*
		 * 1.哈希结构的底层是如何实现的 2.HashSet是如何去除重复元素的
		 */
	}
}

运行结果：

实例2：

package com.ff.colletion.day3;

import java.util.HashSet;


public class HashSetDemo2 {
	 /*
	   Set 不能存储重复元素
	   HashSet  无序存储(不是按照添加顺序排列)
	  */
	public static void main(String [] args) {
	 HashSet <String> set = new HashSet <String>();
	                 set.add("a");
	                 set.add("x");
	                 set.add("s");
	                 set.add("p");
	                 set.add("通话");
	                 set.add("重地");
	                 set.add("b");
	    System.out.println(set);
	    
	    /*
	      1.哈希结构的底层是如何存储数据
	                哈希表 :哈希表本质也是数组
	      
	      2.HashSet是如何去除重复元素的
	                      先用元素的哈希值比较(快) 但是内容不同,hash值可能相同
	         hash相同时,再使用equals()方法判断内容是否相等   (安全可靠,但是效率低)
	        
	                     双保险:保证效率,又保证了安全
	     */
	}          
}

运行结果：

实例3：创建一个学生类实现Comparable接口

package com.ff.javaCollection.day3;

import java.util.Objects;

public class Student implements Comparable<Student> {
    private int num;
    private String name;

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

    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(num, name);
    }

    @Override
    public int compareTo(Student o) {
        int result = this.num - o.num;
        return result;
    }
}

实例：

package com.ff.javaCollection.day3;
/*
HashSet是如何判断内容重复的
1.每次添加元素时会用内容的hash值来判断是否相等，但hash值这种方法不安全，可能会出现内容不同但hash值相同（但用这种方法速度快），
2.出现内容不同，hash值相同（又称为hash碰撞，hash冲突）时，使用equals()方法比较，比较的是内容是否相等（速度慢但是安全）
hash值怎么来？
调用hashCode()方法，两种情况：1.类中已经重写了hashCode()，例如String类，根据内容来计算hash值2.类中没有重写hashCode(),调用Object类中的hashCode()
自己类中重写hashCode()，根据内容计算hash值，当hash值相同时调用equals()判断内容是否相等
 */
import java.util.HashSet;
/*
需要重写toString()方法，否则输出时默认调用Object类中的toString(),我们看不懂的东西
当没有重写hashSet()和equals()方法时候，相同的元素也可以加入
输出结果为：
[Student{num=3, name='重地'}, Student{num=2, name='通话'}, Student{num=1, name='wang'}, Student{num=1, name='wang'}]
当重写过hashSet()和equals()方法时候，会调用自己类中的hashSet()和equals()方法，则相同的元素不可以加入
输出结果为：
[Student{num=2, name='通话'}, Student{num=3, name='重地'}, Student{num=1, name='wang'}]
 */
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
         Student student1 = new Student(1,"wang");
         Student student2 = new Student(2,"通话");
         Student student3 = new Student(3,"重地");
         Student student4 = new Student(1,"wang");
         hashSet.add(student1);
         hashSet.add(student2);
         hashSet.add(student3);
         hashSet.add(student4);
        System.out.println(hashSet);
    }
}

运行结果：

TreeSet

实例1：

package com.ff.javaCollection.day3;

import java.util.TreeSet;

/*
set不可以存储重复元素
TreeSet可以按照元素的自然顺序排列，底层是红黑树
在String中 compareTo()方法会在add()方法中调用
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("1");
        treeSet.add("3");
        treeSet.add("2");
        treeSet.add("1");
        treeSet.add("4");
        System.out.println(treeSet);
    }
}

运行结果：

实例2：

package com.ff.javaCollection.day3;
/*
在Student类中compareTo()不会在add()方法中进行调用
直接运行会出现以下错误java.lang.ClassCastException: com.ff.javaCollection.day3.Student cannot be cast to java.lang.Comparable
需要在student中重写compareTo()方法
 */
import java.util.TreeSet;

public class TreeSetDemo2 {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        Student student1 = new Student(1,"wang");
        Student student2 = new Student(2,"通话");
        Student student3 = new Student(3,"重地");
        Student student4 = new Student(1,"wang");
        treeSet.add(student1);
        treeSet.add(student2);
        treeSet.add(student3);
        treeSet.add(student4);

        System.out.println(treeSet);
    }
}

运行结果：

实例3：

package com.ff.javaCollection.day3;
/*
TreeSet没有索引的下标，所以不可以使用for循环遍历
1.stream()
2.forEach()
3. Iterator()
 */

import java.util.Iterator;
import java.util.TreeSet;

public class SetBianLi {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("1");
        treeSet.add("3");
        treeSet.add("2");
        treeSet.add("1");
        treeSet.add("4");
        //treeSet.stream().forEach((a)-> System.out.println(a));
        /*for (String t:treeSet) {
            System.out.println(t);
        }*/
        Iterator<String> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

运行结果：

Map

Map 集合：键值对存储，键不可以重复，值可以重复

TreeMap

实例：

package com.ff.javaCollection.day4;
/*
TreeMap
键值对存储，键不可以重复
可以根据键的自然顺序排序，指定的键的类型的类必须实现Comparable接口，在排序中使用
 */
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        TreeMap<String,String> treeMap = new TreeMap<>();
        treeMap.put("3","1");
        treeMap.put("3","2");
        treeMap.put("1","1");
        treeMap.put("5","5");
        treeMap.put("2","2");
        treeMap.put("0","0");
        System.out.println(treeMap);

    }
}

运行结果：

HashMap

实例：

package com.ff.javaCollection.day4;
/*
Map 集合
键值对存储，键不可以重复，值可以重复
HashMap
键是无序的
如果有重复的值，后面的值会把前面的值覆盖
可以存储一个为空的键
 */
import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<Integer,String> hashMap = new HashMap<>();
        hashMap.put(2,"13");
        hashMap.put(2,"12");
        hashMap.put(1,"1");
        hashMap.put(4,"4");
        hashMap.put(3,"3");
        hashMap.put(null,"3");
        hashMap.put(null,"30");
        System.out.println(hashMap);
        hashMap.remove(2);//删除键为2的
        //hashMap.clear();//清楚集合中的所有元素
        System.out.println(hashMap.containsKey(5));//若包含键为5的就返回true
        System.out.println(hashMap.containsValue(3));//若包含值为3 的就返回true
        System.out.println(hashMap.isEmpty());//判断是否为空
        System.out.println(hashMap.size());//获取hashMap中有几组键值对
        System.out.println(hashMap.get(4));//得到键所对应的值并返回

    }
}

运行结果：

Hashtable

实例：

package com.ff.javaCollection.day4;
/*
Hashtable
无序的
容量为11
线程安全
 */
import java.util.Hashtable;

public class HashTableDemo {
    public static void main(String[] args) {
        Hashtable<String, String> hashTable = new Hashtable<>();
        hashTable.put("d", "1");
        hashTable.put("a", "2");
        hashTable.put("c", "3");
        hashTable.put("b", "4");
        // hashTable.put(null,"4"); 不允许存放为null的键，否则会出异常 java.lang.NullPointerException
        System.out.println(hashTable);
    }
}

运行结果：

实例：

package com.ff.javaCollection.day4;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
Map集合的遍历
1.流的方式 2.forEach 3.entrySet()+forEach 4. entrySet()+Iterator
 */
public class MapBianLi {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("5", "5");
        hashMap.put("2", "2");
        hashMap.put("3", "3");
        hashMap.put("6", "6");
        hashMap.put("1", "1");
        //hashMap.forEach((k,v)-> System.out.println(k+":"+v));

       /* //keyset()先获取到hashMap中的所有键，存储到集合set中，再对set集合进行遍历，通过get()方法得到对应的value。遍历效率低，所以很少使用
        Set<String> keyset = hashMap.keySet();
        for (String key: keyset) {
            System.out.println(key+":"+hashMap.get(key));
        }*/

       /* //entrySet()将hashmap集合中的键值对封装到一个Entry对象中
        Set<Map.Entry<String,String>> entrySet = hashMap.entrySet();
        for (Map.Entry<String,String> entry : entrySet) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }*/

        Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, String>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry = it.next();
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

运行结果：

Collections

Collections中定义的方法

实例：

package com.ff.javaCollection.day4;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
    public static void main(String[] args) {
       /* ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");
        Collections.addAll(arrayList,"e","f","g");//添加元素
        System.out.println(arrayList);
        Collections.sort(arrayList);//排序
        System.out.println(Collections.binarySearch(arrayList,"f"));//使用二分法查找元素（前提，集合中元素必须有序）
        */

        ArrayList<String> arrayList1 = new ArrayList();
        arrayList1.add("a");
        arrayList1.add("b");
        arrayList1.add("c");
        arrayList1.add("d");

        ArrayList<String> arrayList2 = new ArrayList();
        arrayList2.add("e");
        arrayList2.add("f");
        arrayList2.add("g");
        Collections.copy(arrayList1, arrayList2);//此方法沒有返回值，不可以输出。dest集合中的size不可以小于src集合中的size
        System.out.println(arrayList1);

        //List<Object> list = Collections.emptyList();//此方法中不可以加入元素
        //list.add("x");

        Collections.fill(arrayList1, "s");//用s填充arrayList1中的所有元素
        System.out.println(arrayList1);

        System.out.println(Collections.max(arrayList2));//找出arrayList2中最大的元素

        Collections.replaceAll(arrayList2, "e", "E");//在arrayList2中用E代替e
        System.out.println(arrayList2);

        Collections.reverse(arrayList2);//逆序输出arrayList2
        System.out.println(arrayList2);

        Collections.swap(arrayList2, 1, 2);//交换顺序
        System.out.println(arrayList2);
    }
}

运行结果：