集合的概念
-
当我们需要保存一组一样(类型相同)的元素的时候,我们应该使用一个容器来存储,数组就是这样一个容器。
数组有什么缺点?
数组一旦定义,长度将不能再变化。
● 然而在我们的开发实践中,经常需要保存一些变长的数据集合,于是,我们需要一些能够动态增长长度的容器来保存我们的数据。
● 而我们需要对数据的保存的逻辑可能各种各样,于是就有了各种各样的数据结构。Java中对于各种数据结构的实现,就是我们用到的集合。
集合 API
集合体系概述 :
Java的集合框架是由很多接口、抽象类、具体类组成的,都位于java.util包中。
collection接口
● Collection 接口-定义了存取一组对象的方法,其子接口Set和List分别定义了存储方式。
● Set 中的数据对象没有顺序且不可以重复。
● List 中的数据对象有顺序且可以重复。
Collection<E>集合可以使用泛型向集合中传入一个参数,如果不传默认是Object,都必须存储引用类型
public static void main(String[] agrs){ Collection c = new ArrayList();//默认是Object类型 c.add("a"); c.add(1);//自动装箱为包装类型 c.add(true); }
在Java中存储为Object可以,但是实际取出时必须给出具体的类型,即向下转型时存在很大的安全隐患,因此建议使用泛型给出具体的类型。
eg:Collection <String> c = new ArrayList<String>();
public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); c.add("a"); c.add("b"); c.add("c"); c.add("d"); c.add("e"); //c.remove("a");//删除指定的元素,第一次出现的 //c.clear();//清空 System.out.println(c.isEmpty());//是否为空 System.out.println(c.contains("a"));//是否包含 System.out.println(c.size()); System.out.println(c); Object[] objs1 = c.toArray();//集合转数组 System.out.println(Arrays.toString(objs1)); String[] objs2 = c.toArray(new String[c.size()]);//集合转数组,可以指定集合的类型 }
public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); c.add("a"); c.add("b"); c.add("c"); c.add("d"); Collection<String> c1 = new ArrayList<String>(); c1.add("a"); c1.add("b"); c1.add("c"); c.addAll(c1); c.removeAll(c1);//删除了c1在c中的内容 System.out.println(c.containsAll(c1)); System.out.println(c.retainAll(c1));//只保留c与c1相交的部分,元素发生变化返回true,不发生变化返回false }
泛型
为什么用泛型?
早期的Object类型可以接收任意的对象类型,但是在实际的使用中,会有类型转换的问题。也就存在这隐患,所以Java提供了泛型来解决这个安全问题。
什么是泛型?
● 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。
● 参数化类型,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式,然后在使用/调用时传入具体的类型。
泛型类
泛型有三种使用方式,分别为:泛型类、泛型接口、泛型方法.
泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。
一个最普通的泛型类:
public class Demo<T>{ / /T可以为任意标识符,常见的如T、E、K、V等形式的参数常用于表示泛型
private T key; / /key这个成员变量的类型为T,T的类型由外部指定
public Generic(T key) { / /泛型构造方法形参key的类型也为T,T的类型由外部指定
this.key = key;
}
public T getKey(){ / /泛型方法getKey的返回值类型为T,T的类型由外部指定
return key;
}
}
传入的实参类型需与泛型的类型参数类型相同,即为Integer.
Demo<Integer> genericInteger = new Demo<Integer>(123456);
1.泛型的类型参数只能是类类型 2.泛型的类型参数可以有多个。3.如果没有定义具体类型,默认为Object从泛型类派生子类
子类也是泛型类,子类和父类的泛型类型要一致
class A<T> extends Demo<T>
子类不是泛型类,父类要明确泛型的数据类型
class A extends Demo<String>泛型接口
泛型接口与泛型类的定义及使用基本相同。
public interface Demo<T> { //定义一个泛型接口
public T next();
}
子类也是泛型类,子类和父类的泛型类型要一致
class A<T> implements Demo<T>{
@Override
public T next() {
return null;
}
}
泛型通配符
● 什么是类型通配符?
● 类型通配符一般是使用"?"代替具体的类型实参。
● 所以,类型通配符是类型实参,而不是类型形参。
public void showKeyValue1(Demo<Number> obj){
}
Demo<Integer> gInteger = new Demo<Integer>(123);
Demo<Number> gNumber = new Demo<Number>(456);
showKeyValue(gNumber);
showKeyValue(gInteger);这个方法编译器会为我们报错:Generic<java.lang.Integer>
泛型通配符
● 类型通配符上限
类/接口<?extends实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的子类类型。
● 类型通配符下限
类/接口<?super实参类型>
要求该泛型的类型,只能是实参类型,或实参类型的父类类型。
类型擦除
泛型是Java 1.5版本才引进的概念,在这之前是没有泛型的,但是,泛型代码能够很好地和之前版本的代码兼容。那是因为,泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除。
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());
打印的结果为 true 是因为 List<String>和 List<Integer>在 jvm 中的 Class 都是 List.class。
泛型信息被擦除了。
泛型类被类型擦除后,相应的类型就被替换成 Object 类型或者上限类型类型擦除
案例:
public class Erasure <T>{
T object;
public Erasure(T object) {
this.object = object;
}
}
Erasure 是一个泛型类,我们查看它在运行时的状态信息可以通过反射。
Erasure<String> erasure = new Erasure<String>("hello");
Field[] fs = eclz.getDeclaredFields();
for ( Field f:fs) {
System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}
Field name object type:java.lang.Object
List 接口及实现类
● List继承了Collection接口,有三个实现的类
- ArrayList 底层实现是数组结构,线程不安全
数组列表,数据采用数组方式存储。
-LinkedList 底层是链表结构
链表
-Vector 底层是数组实现,是线程安全的
数组列表,添加同步锁,线程安全的
ArrayList 查询块,增删慢
public static void main(String[] args){ ArraysList<String> alist = new ArraysList<>();//创建一个长度为10的底层数组,第一次添加元素时,真正创建数组 ArraysList<String> alist = new ArraysList<>(20);//创建长度为20的数组 alist.add("a"); alist.add("b"); alist.add("c"); alist.add(0,"d");//向指定位置插入数据 alist.set(1,"B");//替换指定位置的元素 System.out.println(alist.get(2));//返回此列表中指定的元素 System.out.println(alist.indexof("b"));//返回此列表中指定元素的第一次出现的索引,如果此列表不包含此元素,则返回-1 System.out.println(alist.remove(1));//删除并返回指定索引的元素 System.out.println(alist); }
public class ArrayListDemo3 { public static void main(String[] args) { ArrayList<String> alist = new ArrayList<>(); alist.add("c"); alist.add("b"); alist.add("a"); alist.add("d"); //new 接口(){ 方法重写 } 创建了一个匿名内部类对象 /*alist.sort(new Comparator<String>() { @Override public int compare(String o1,String o2) { return o1.compareTo(o2); } }); */ //创建了一个自定义String比较器类的对象 // alist.sort(new StringComparator()); //alist.sort((String o1,String o2)->{ return o1.compareTo(o2); }); System.out.println(alist); } } 结果:[a,b,c,d] //自定义String比较器 package com.ffyc.javaCollection2.day1.list; import java.util.Comparator; public class StringComparator implements Comparator<String>{ @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }
LinkedList 查询慢,增删快
public static void main(String[] args){ LinkedList<String> llist = new LinkedList(); llist.add("a"); llist.add("b"); llist.add("c"); llist.add("d"); llist.add("a"); //index<size/2从头结点开始向后找,否则从尾结点向前找 System.out.println(llist.get(3)); System.out.println(llist); }
Vector 底层也是数组实现,但是是线程安全的
public static void main(String[] args){ Vector<String> v = new Vector(); v.add("a"); v.add("a"); v.add("a"); v.add("a"); v.add("a"); v.add("a"); System.out.println(v) }
List接口集合迭代
public static void main(String[] args){ ArrayList<String> alist = new ArrayList(); alist.add("a"); alist.add("b"); alist.add("c"); alist.add("d"); //for循环遍历 for(i=0;i<alist.size();i++){ System.out.println(alist.get(i)); } /*for 支持在遍历的过程删除集合中的元素,注意元素向前移动,i++,会漏掉元素 */ ArrayList<String> alist = new ArrayList(); alist.add("a"); alist.add("a"); alist.add("a"); alist.add("b"); alist.add("c"); alist.add("d"); for(i=0,i<alist.size();i++){ if(alist.get(i).equals("a")){ alist.remove(i); } } System.out.println(alist); 结果:[a,b,c,d] //增加for for(String s: alist){ System.out.println(s); } /* 增强for循环 不支持在遍历时删除元素 */ for(String s: alist){ if(s.equals("a")){ alist.remove(s); break; } } System.out.println(alist); 结果:[a,a,b,c,d] //通过迭代器 Iterator<String> it = alist.iterator();//返回一个迭代器对象,控制元素的遍历 while(it.hasNext()){ String s = it.next(); System.out.println(s); } /* 通过迭代器 */ Iterator<String> it = alist.iterator(); while(it.hasNext()){ String s = it.next(); if(s.equals("a")){ it.remove();//使用迭代器中的方法进行遍历 } } 结果:[b,c,d] //listIterator() 只能对List接口下的实现类进行遍历 从前先后: ListIterator<String> lit = alist.listIterator(); while(lit.hasNext()){ System.out.println(lit.next()); } 从后先前: ListIterator<String> lit = alist.listIterator(alist.size()); while(lit.hasPrevious()){ System.out.println(lit.previous()); } }
Set接口
● Set接口继承了Collection接口。
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
● Set接口有两个实现类
● HashSet
HashSet类中的元素不能重复,即彼此调用equals方法比较,都返回false。
底层数据结构是哈希表+链表
哈希表依赖于哈希值存储
● TreeSet
可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)
HashSet
HashSet中添加元素时如何去除重复元素?
判断要求是即快又安全。
System.out.println("abc".equals("abc"));equals判断安全但效率低。
怎样提高比较速度?
使用内容的hash值比较(哈希值是整数),但是哈希值不安全(有可能内容不同,哈希值相同)
最终解决方案就是先用内容计算的哈希值比较,如果出现了相同的哈希值,那么再调用equals方法判断内容分是否相同
TreeSet
public static void main(String[] args){ TreeSet<String> tset = new TreeSet(); tset.add("s"); tset.add("a"); tset.add("c"); tset.add("b"); tset.add("d"); tset.add("s"); System.out.println(tset); } 结果:[a,b,c,d,s]
遍历方式:
增强for循环 和 迭代器遍历