java集合框架

集合框架

一,Collection 接口

Collection对象是将多个元素组成一个单元的对象 集合用于存储、检索和操纵数据 集合框架是用于表示和操纵集合的统一体系结构

集合框架包含三个组件

集合框架的优点

提供有用的数据结构和算法，从而减少编程工作 提高了程序速度和质量,因为它提供了高性能的数据结构和算法 允许不同 API 之间的互操作，API之间可以来回传递集合 可以方便地扩展或改写集合

二,List接口的实现类

ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

LinkedList采用链表存储方式。插入、删除元素时效率比较高

1.ArrayList

package com.sk.col;
​
​
import java.util.ArrayList;
import java.util.List;
​
/**
 * ClassName: ArraayList <br/>
 * Description: <br/>
 * date: 2021/12/13 8:37<br/>
 *
 * @author 斑马<br />
 */
public class ArrayListTest {
    public static void main(String[] args) {
        Dog d1=new Dog("小猫","公");
        Dog d2=new Dog("大黄","公");
        Dog d3=new Dog("大黄222","公");
        //和原来自己写的可变长数组没有区别
        List list=new ArrayList();
        boolean flag1= list.add(d1);//添加
        list.add(d2);
        list.add(d2);//允许重复
        list.add(0,d3);//在指定位置添加元素
        boolean flag=list.contains(d1);//判断元素是否存在
        //System.out.println(list.contains(new Dog("小猫","公")));
        Dog dd= (Dog) list.remove(0);//通过索引删除,删除成功返回删除的元素,失败返回null
        list.remove(d1);//通过对象删除
        System.out.println(flag);
        list.set(0,new Dog("老张","母"));//修改(设置) set(索引,修改后的元素)
        //遍历
        for (int i=0;i<list.size();i++){
            Dog d= (Dog) list.get(i);//根据索引获取数据
            System.out.println(d.getName()+d.getSex());
        }
        //iterator迭代器:用来遍历集合  Iterator it=list.iterator()  iterator()返回迭代器
        //it.hasNext() 判断是否有下一个元素
//      for (Iterator it = list.iterator();it.hasNext();){
//          Dog pp= (Dog) it.next();//it.next()获取元素
//          System.out.println(pp);
//      }
        Iterator it = list.iterator();
        while (it.hasNext()){
            Dog pp= (Dog) it.next();
            System.out.println(pp);
        }
    }
}
class Dog{
    private String name;
    private String sex;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getSex() {
        return sex;
    }
​
    public void setSex(String sex) {
        this.sex = sex;
    }
​
    public Dog(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
}

2.Queue队列

• 设计用于在处理之前保留元素的集合。 除了基本的Collection操作之外，队列还提供额外的插入，提取和检查操作。

• 队列通常但不一定是以FIFO（先进先出）方式排序元素。 除了优先级队列之外，优先级队列是根据提供的比较器对元素进行排序，还是元素的自然排序，以及对元素LIFO（先进先出）进行排序的LIFO队列（或堆栈）。 无论使用什么顺序，队列的头都是通过调用remove()或poll()删除的元素。 在一个FIFO队列，所有新元素插入到队列的尾部 。 其他类型的队列可以使用不同的布局规则。 每个Queue实现必须指定其排序属性。

• AbstractQueue ， ArrayBlockingQueue ， ArrayDeque ， ConcurrentLinkedDeque ， ConcurrentLinkedQueue ， DelayQueue ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedList ， LinkedTransferQueue ， PriorityBlockingQueue ， PriorityQueue ， SynchronousQueue

package com.sk.col;
​
import java.util.ArrayDeque;
import java.util.Iterator;
​
/**
 * ClassName: QueTest <br/>
 * Description: <br/>
 * date: 2021/12/13 14:07<br/>
 *
 * @author 斑马<br />
 */
public class QueTest {
    public static void main(String[] args) {
        //可变长的数组队列
        ArrayDeque ad=new ArrayDeque(2);
        ad.add("张三");
        ad.addLast("孙七");//插入最后
        ad.offer("李四");
        ad.offerFirst("王五");
        ad.offerLast("王五5");
        ad.addFirst("赵六");//插入最前面
        System.out.println("**********************");
        //检索，但不删除，由这个deque表示的队列的头。
        String s1= (String) ad.element();
        System.out.println(s1);
        System.out.println(ad.getFirst());
        System.out.println(ad.getLast());
        System.out.println(ad.poll());//检索并删除
        System.out.println("**************************");
        for (Iterator it =ad.iterator();it.hasNext();){
            String str= (String) it.next();
            System.out.println(str);
        }
    }
}
​

3.LinkedList

• public class LinkedList<E>
  extends AbstractSequentialList<E>
  implements List<E>, Deque<E>, Cloneable, Serializable
  ​
  list 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。 
  ​

package com.sk.col;
​
import java.util.Iterator;
import java.util.LinkedList;
​
/**
 * ClassName: LinkedTest <br/>
 * Description: <br/>
 * date: 2021/12/13 15:06<br/>
 *
 * @author 斑马<br />
 */
public class LinkedTest {
    public static void main(String[] args) {
        Dogs d1=new Dogs("张三","公");
        Dogs d2=new Dogs("一百号","公");
        Dogs d3=new Dogs("阿哲","公");
        Dogs d4=new Dogs("大壮","公");
        Dogs d5=new Dogs("老却","公");
        Dogs d6=new Dogs("小黄","公");
        //创建对象
        LinkedList list=new LinkedList();
        list.add(d1);//list  boolean
        list.add(1,d2);//需要注意集合的长度,不能超出范围
        list.addFirst(d3);
        list.addLast(d4);
        list.offer(d4);
        list.offerFirst(d5);
        list.offerLast(d5);
        list.push(d6);//将元素推送到由此列表表示的堆栈上。
        list.push(d1);
        System.out.println(list.peek());//检索但不删除
        System.out.println(list.poll());//检索并删除
        System.out.println(list.poll());
        list.remove();//检索并删除此列表的头
        list.remove(3);//根据下标删除
        //用指定的元素替换此列表中指定位置的元素
        list.set(0,d6);
        System.out.println("*******************************");
        for (int i=0;i<list.size();i++){
            Dogs d= (Dogs) list.get(i);
            System.out.println(d);
        }
        for (Iterator it=list.iterator();it.hasNext();){
            Dogs d= (Dogs) it.next();
            System.out.println(d);
        }
        for(Object o:list){
            Dogs d= (Dogs) o;
            System.out.println(d);
        }
​
    }
}
​

三.Set接口

Set 接口继承 Collection 接口，与Collection接口中的方法完全一样，但它不允许集合中存在重复项并且保存 数据是无序的。 HashSet集合内的元素是无序排列的，是线程安全的，允许集合元素值为null TreeSet它的集合元素是有序排列的,不允许集合元素值为null

1.HashSet

• public class HashSet<E>
  extends AbstractSet<E>
  implements Set<E>, Cloneable, Serializable

  此类实现Set接口，由哈希表（实际为HashMap实例）支持。 对集合的迭代次序不作任何保证; 特别是，它不能保证订单在一段时间内保持不变。 这个类允许null元素。

  • Modifier and Type	Method and Description
    boolean	add(E e) 将指定的元素添加到此集合（如果尚未存在）。
    void	clear() 从此集合中删除所有元素。
    Object	clone() 返回此 HashSet实例的浅层副本：元素本身不被克隆。
    boolean	contains(Object o) 如果此集合包含指定的元素，则返回 true 。
    boolean	isEmpty() 如果此集合不包含元素，则返回 true 。
    Iterator<E>	iterator() 返回此集合中元素的迭代器。
    boolean	remove(Object o) 如果存在，则从该集合中删除指定的元素。
    int	size() 返回此集合中的元素数（其基数）。
    Spliterator<E>	spliterator() 在此集合中的元素上创建late-binding和故障快速 Spliterator 。

package com.sk.set;
​
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
​
/**
 * ClassName: HashSetTest <br/>
 * Description: <br/>
 * date: 2021/12/14 8:42<br/>
 *
 * @author 斑马<br />
 */
public class HashSetTest {
    public static void main(String[] args) {
        Dogs d1=new Dogs("张三","公");
        Dogs d2=new Dogs("一百号","公");
        Dogs d3=new Dogs("阿哲","公");
        Dogs d4=new Dogs("大壮","公");
        Dogs d5=new Dogs("老却","公");
        Dogs d6=new Dogs("小黄","公");
        Set set=new HashSet();
        set.add(d1);
        set.add(d2);
        set.add(d3);
        set.add(d4);
        set.add(d5);
        set.add(null);//允许null
        set.add(d6);//顺序和添加顺序无关
        set.add(d1);//重复了,会把原来的覆盖
        set.remove(d1);//删除
        //没有修改的方法:删除后添加一个修改后的对象
        //遍历
        for (Iterator it=set.iterator();it.hasNext();){
            Dogs d= (Dogs) it.next();
            System.out.println(d);
        }
    }
}

​

2.TreeSet

• public class TreeSet<E>
  extends AbstractSet<E>
  implements NavigableSet<E>, Cloneable, Serializable

  A NavigableSet实现基于TreeMap 。 的元件使用其有序natural ordering ，或由Comparator集合创建时提供，这取决于所使用的构造方法

java.lang.ClassCastException  添加值TreeSet的对象,必须实现Comparable

public interface Comparable<T>

该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法

package com.sk.set;

import java.util.TreeSet;

/**
 * ClassName: TreeSetTest <br/>
 * Description: <br/>
 * date: 2021/12/14 9:29<br/>
 *
 * @author 斑马<br />
 */
public class TreeSetTest {
	public static void main(String[] args) {
		Penguin p1=new Penguin("zs","x",12);
		Penguin p2=new Penguin("ls","x",15);
		Penguin p3=new Penguin("lz","y",22);
		Penguin p4=new Penguin("jj","y",2);
		Penguin p5=new Penguin("qs","y",2);
		TreeSet set=new TreeSet();
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		set.add(p5);
		for (Object o:set){
			Penguin p= (Penguin) o;
			System.out.println(p);
		}
	}
}

//java.lang.ClassCastException  添加值TreeSet的对象,必须实现Comparable
//public interface Comparable<T>该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法
class Penguin implements Comparable<Penguin>{//<T>当前类  T可以将此对象与之进行比较的对象类型

	private String name;
	private String sex;
	private int age;
	@Override
	public int compareTo(Penguin o) {
		//根据年龄排序
		//return age-o.getAge();//正数,负数,0  大于,小于,等于
		//根据名字的hashCode值排序
		//return o.getName().hashCode()-name.hashCode();
		//根据性别排序
		if(o.getSex().hashCode()==sex.hashCode()){
			return 1;
		}
		return o.getSex().hashCode()-sex.hashCode();
	}
	public String getName() {
		return name;
	}

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

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

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


}

四,Map接口

Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作

建立国家英文简称和中文全名间的键值映射，并通过key对value进行操作，应该如何实现数据的存储和操作呢？

方法名	说 明
Object put(Object key, Object val**)**	以键值对”的方式进行存储
Object get (Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key)	删除由指定的键映射的“键值对
int size()	返回元素个数
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean containsKey (Object key)	如果存在由指定的键映射的“键值对”，返回true

package com.sk.map;

import java.util.*;

/**
 * ClassName: MapTest <br/>
 * Description: <br/>
 * date: 2021/12/14 14:17<br/>
 *
 * @author 斑马<br />
 */
public class MapTest {
	public static void main(String[] args) {
		//<键key,值value>
		Map<String,String> map=new HashMap<>();
		map.put("US","美国");
		map.put("CN","中国");
		map.put("RU","俄罗斯");
		System.out.println("长度:"+map.size());
		//key值是Set集合
		Set keys =map.keySet();
		System.out.println(keys);
		//所有的value取值Collection集合
		Collection values= map.values();
		System.out.println(values);
		//通过键key获取value
		String str=map.get("CN");
		System.out.println(str);
		//判断key是否存在
		boolean flag=map.containsKey("CN");
		System.out.println(flag);
		//通过key值删除
		String v= map.remove("US");
		System.out.println(v);
		//修改  通过key修改value
		String va= map.replace("RU","苏联");
		System.out.println(va);
		//遍历   通过key,获取value
		Set set=map.keySet();//获取key的集合
		Iterator<String> it=set.iterator();//通过Set获取迭代器
		while (it.hasNext()){
			String key=it.next();//获取单个的key
			String value=map.get(key);//通过key获取value
			System.out.println(key+":"+value);
		}
		System.out.println("*****************************");
		for(Iterator<String> its=map.keySet().iterator();its.hasNext();){
			String key=its.next();//获取单个的key
			String value=map.get(key);//通过key获取value
			System.out.println(key+":"+value);
		}
		System.out.println("*****************************");
		for (String key:map.keySet()){
			String value=map.get(key);
			System.out.println(key+":"+value);
		}
	}
}

五,操作集合的工具类Collections

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

public static void reverse(List<?> list)

shuffle(List<?> list)` 使用默认的随机源随机排列指定的列表。

sort(List<T> list) 根据其元素的natural ordering对指定的列表进行排序。

sort(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。

package com.sk.util;

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

/**
 * ClassName: ColTest <br/>
 * Description: <br/>
 * date: 2021/12/15 8:08<br/>
 *
 * @author 斑马<br />
 */
public class ColTest {
	public static void main(String[] args) {
		Penguin p1=new Penguin("zhangsan",12);
		Penguin p2=new Penguin("ls",20);
		Penguin p3=new Penguin("lss",18);
		Penguin p4=new Penguin("zhaoliu",33);
		List<Penguin> list=new ArrayList<>();
		list.add(p1);
		list.add(p2);
		list.add(p3);
		list.add(p4);
		System.out.println("*****************************");
		for (Penguin p:list){
			System.out.println(p);
		}
		Collections.reverse(list);//反转
		Collections.shuffle(list);//使用默认的随机源随机排列指定的列表。
		//根据比较器进行排序,(要排序的集合,比较器)
		Collections.sort(list,new PenguinCom());
		//根据其元素的natural ordering对指定的列表进行排序。
		System.out.println("*****************************");
		for (Penguin p:list){
			System.out.println(p);
		}
	}
}
/**自定义的比较器:用来比较两个penguin的大小*/
class PenguinCom implements Comparator<Penguin> {
	@Override
	public int compare(Penguin o1, Penguin o2) {
		//return o1.getAge()-o2.getAge();
		return o2.getName().hashCode()-o1.getName().hashCode();
	}
}
 

六,泛型集合

1.没有泛型的情况

强制类型转换时容易出现的异常问题

没有办法限制集合存储的数据类型

2.泛型的作用

JDK1.5使用泛型改写了集合框架中的所有接口和类

泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，引入了泛型，它允许指定集合里元素的类型

package com.sk.set;

import java.util.ArrayList;
import java.util.List;

/**
 * ClassName: Dome01 <br/>
 * Description: <br/>
 * date: 2021/12/14 10:15<br/>
 *
 * @author 斑马<br />
 */
public class Dome01 {
	public static void main(String[] args) {
		//list现在只能存String类型
		List<String> list=new ArrayList<>();//右边<>泛型可以省略
		list.add("zs");
		//list.add(123);//有泛型了之后,每次添加,jvm都会检查数据类型
		for (String s:list) {//有了泛型之后,集合的遍历不再需要强制类型转换
			System.out.println(s);
		}
		for (int i=0;i<list.size();i++){
			String s=list.get(i);
		}
	}
}

3.泛型好处

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个安全机制 好处之一：将运行时期出现问题ClassCastException转移到了编译时期，方便程序员解决问题，减少运行时出现的问题 好处之二：避免了强制转换麻烦 用处：在java中只要用到集合保存数据时就需要使用泛型，让程序更健壮

集合类对比

1.ArrayList,LinkedList和Vector的区别

ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

LinkedList采用链表存储方式。插入、删除元素时效率比较高

Vector除了线程安全外，基本和ArrayList一样， ArrayList和LinkedList都是线程不安全的

2.Hashtable和HashMap的异同

实现原理、功能相同，可以互用 主要区别 Hashtable继承Dictionary类，HashMap实现Map接口 Hashtable线程安全，HashMap线程非安全 Hashtable不允许null值，不允许重复，HashMap允许null值，但不允许重复，如果重复，将直接覆盖