上一章节:JavaSE字符串(JavaSE大全)
集合框架介绍
集合框架是JAVA中一系列关于集合的实现类和接口。
集合可以看做是一种容器,用来存储对象(集合只能存对象),与数组相类似,但特性不一样。集合的功能更强大,集合类的空间容量时可以调整的。集合类都在java.util包下。
集合和数组的区别:
(1)集合专门用来存放对象,不能直接存储基本数据类型,但可以存储包装类型。数组可以存放基本数据类型等数据。
(2)集合中的数据可以是不同类,数组中只能存放同类型数据
(3)数组一旦被定义,不可以被修改,集合中的数据可以被修改
集合框架结构
Java的集合框架从整体上可以分为两大接口。
Collection接口:该接口下的所有实现类均存储的是单一对象。
Map接口:该接口下的所有实现类均存储的是key-value(键值对)形式的数据。
结构图:
还有三个分支,均为上面两大接口服务。
(1)Iterator接口(迭代器),主要用于遍历Collection接口的及其子类而设计。
(2)Comprator接口(比较器),在集合中存储对象的时候,用于对象之间的比较。
(3)Collections工具类,提供很多静态方法,来对Collection集合进行操作
常用实现类:
List接口:ArrayList,LinkedList
Set接口:HashSet,TreeSet
Map接口:HashMap,HashTable
List集合
List接口:
是Collection接口的子接口,存放的元素有序且允许重复。
List集合类常用的有:
ArrayList(重点) LinkedList Vector(了解即可)
创建ArrayList对象
ArrayList list=new ArrayList();
创建对象后,我们可以使用Collection接口中的方法对ArrayList的各种操作。
这些方法是定义在Collection接口中的方法,所以Collection接口中其他集合类都可以通用,包括List中的几个实现类。
Collection接口中定义的方法:
(1)boolean add(E element); 向collection中添加元素。
(2)boolean remove(Object element); 在collection中移除指定的元素。
(3)int size(); 返回此collection中的元素数。
(4)boolean isEmpty(); 判断此collection中是否为空。
(5)boolean contains(Object obj); 判断此collection是否包含指定的元素。
(6)boolean contains(Collection<?> c); 判断此collection是否包含指定collection中的所有元素。
(7)boolean addAll(Collection<? extends E> c);将指定collection中的所有元素添加到此collection中
(8)boolean removeAll(Collection<?> c); 移除此collection中那些也包含在指定collection中的所有
元素。
(9)void clear(); 移除些collection中所有的元素。
(10)boolean retainAll(Collection<?> c); 仅保留此collection中那些也包含在指定collection的元素。
(11)Iterator iterator(); 返回在此collection的元素上迚行迭代的迭代器。
(12)T[] toArray(T[] arr); 把此collection转成数组。
Demo,创建一个Stu实体类
public class Stu {
String name;
int age;
public Stu(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ArrayList l1=new ArrayList();
Stu stu1=new Stu("张三",18);
Stu stu2=new Stu("李四", 20);
Stu stu3=new Stu("王五", 19);
Stu stu4=new Stu("赵六", 19);
//在集合中添加对象
l1.add(stu1);
l1.add(stu2);
l1.add(stu3);
l1.add(stu4);
//打印个数
System.out.println(l1.size());
//删除个数
l1.remove(stu4);
System.out.println(l1.size());
}
另一个demo
public static void main(String[] args) {
ArrayList l1=new ArrayList();
ArrayList l2=new ArrayList();
Stu stu1=new Stu("张三",18);
Stu stu2=new Stu("李四", 20);
Stu stu3=new Stu("王五", 19);
Stu stu4=new Stu("赵六", 19);
Stu stu5=new Stu("傻橙", 19);
Stu stu6=new Stu("E总", 19);
Stu stu7=new Stu("Build", 19);
//在集合中添加对象
l1.add(stu1);
l1.add(stu2);
l1.add(stu3);
l1.add(stu4);
l2.add(stu5);
l2.add(stu6);
l2.add(stu7);
//判断集合是否为空
System.out.println(l1.isEmpty());
System.out.println(l2.isEmpty());
//判断集合中是否包含指定元素
System.out.println(l1.contains(stu7));
System.out.println(l1.contains(stu2));
//将一个集合中所有元素添加到另一个集合中
l1.addAll(l2);
System.out.println(l1.size());
//清空集合中所有元素
l2.clear();
System.out.println(l2.size());
//将Collection转数组
Stu[] sArray=(Stu[])l1.toArray();
}
ArrayList,LinkedList和Vector的区别:
ArrayList:
(1)底层是封装数组实现,分配的是一块连续内存空间
(2)读取快,增删慢
(3)线程不安全
(4)初始大小是10,扩充是扩充50%
LinkedList:
(1)底层封装链表实现,分配的是不连续的内存空间。
(2)增删快,读取慢
(3)线程不安全
(4)没有扩容的机制,使用首尾添加的操作 addFirst()和addList()
Vector
(1)底层封装数组实现
(2)增删插速度都慢
(3)线程安全
(4)初始大小10,扩充时扩充一倍
注:其他操作中,都是使用Collection接口中的方法。
ArrayList l1=new ArrayList();
l1.add("傻橙");
l1.add("E总");
l1.add("缶字");
//索引从0开始,顺序由添加顺序决定
System.out.println(l1.get(1));
for (int i=0;i<l1.size(); i++) {
System.out.println(l1.get(i));
}
Set集合
Set接口:
是Collection接口的子接口,存取的元素无序且不允许重复。
Set接口没有提供Collection接口额外的方法,也就是仍然使用Collection接口已经定义好的方法,与List接口相似,没有get()方法
Set接口常用的实现类有:
HashSet:散列存放,无序
TreeSet:有序存放,自然排序(不是按照存入顺序)
Set接口存,取,删对象都有很高的效率。
**HashSet原理:**根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引,把对象存放在hash表中的相应位置中;
存对象时,首先获得该对象的hashCode值,与hash表中的值进行比较,如果不存在,则直接把该对象存入集合中,并把该hashCode值存入hash表中,此次add操作结束,如果存在,则进行下面的计算。通过“==”操作符判断已经存入的对象与要存入的对象是否为同一对象。如果true则集合认为添加相同对象,add失败。如果false(不是同一对象),则调用要添加的对象的equals()方法,如果返回值为true,则集合认为添加相同对象add失败,否则添加成功。
public static void main(String[] args) {
Stu stu1=new Stu("张三",18);
Stu stu2=new Stu("李四", 20);
Stu stu3=new Stu("王五", 19);
Stu stu4=new Stu("赵六", 19);
//泛型
HashSet<Stu> h1=new HashSet<Stu>();
h1.add(stu1);
h1.add(stu2);
h1.add(stu3);
h1.add(stu4);
h1.add(stu4);
//不能存放相同对象
System.out.println(h1.size());
for (Stu stu : h1) {
System.out.println(stu.getName());
}
}
TreeSet存储原理:存放时会调用集合集合元素的CompareTo()方法,根据该方法的返回值来比较元素之间的大小,然后进行“升序”排列,这种排序方式我们称之为自然排列。(升序排列)
注:如果想采用自然排序,则要存储的对象所属类必须实现Comparable接口。该接口只有一个方法 public int compareTo(Object obj),必须实现该方法。
TreeSet<Integer> ts=new TreeSet<Integer>();
//int类型会自动装箱。
ts.add(1);
ts.add(44);
ts.add(33);
ts.add(0);
for (Integer integer : ts) {
System.out.println(integer);
}
}
Iterator迭代器
迭代器是一种设计模式,他是一个对象,可以遍历序列中的对象。
for循环—有索引
For-each循环—类型统一
Java中迭代器的实现步骤:
(1)使用方法iterator()要求容器(集合就是一种容器)返回一个Iterator。第一次调用Iterator的next()方法时,返回序列的第一个元素。
(2)使用next()获得序列中的下一个元素
(3)使用hasNext()检查序列中是否还有元素
(4)使用remove()将迭代器新返回的元素删除
注:iterator()方法是将java.lang.Iterable接口,被Collection继承。
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add("张三");
hs.add("李四");
hs.add("王五");
hs.add(555);
Iterator it=hs.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
Map集合
Map集合通过键值对(key-value)的形式来存储数据。
Map中,key可以为任意类型,但建议使用String,value也可以是任意类型;
Map集合通过键获取值,查询速度非常快。
Map的实现类:
HashMap(使用频率最高(无序))
TreeMap(自然升序)
HashTab)无序
三个实现类使用步骤是相似的。
使用步骤:
根据键获取值:get(Object key)
根据key删除指定数据:remove(Object key)
注:Map里面key是不可以重复的,当key重复时,后存入的数据会覆盖前面的数据,Map中的值可以重复。
public static void main(String[] args) {
HashMap hm=new HashMap();
hm.put("1","zhangsan");
hm.put("2", "lisi");
hm.put("3","wangwu");
hm.put("2","zhaoliu");
System.out.println(hm.get("1"));
hm.remove("3");
System.out.println(hm.size());
}
Map接口中的常用方法:
(1)Boolean containsKey(Object key)://判断是否包含指定的key。
(2)boolean containsValue(Object value); //判断是否包含指定值的“键-值”对。
(3)Object get(Object key); //返回指定键所映射的值
(4)boolean isEmpty(); //判断此Map中是否有元素。
(5)Set keySet(); //返回此Map中包含的键的Set集。
(6)Collection values(); //返回此Map中包含的值的Collection集。
(7)Object put(Object key, Object value); //将指定的“键-值”对存入Map中
(8)put All(Map m):把一个Map集合存入指定的Map中
(9)Object remove(Object key); //根据指定的键把此“键-值”对从Map中移除。
(10)int size(); //获得些Map中“键-值”对的数量。
(11)void clear(); //清空Map中的所有“键-值”对。
(12)Set<Map.Entry<K,V>> entrySet();
public static void main(String[] args) {
HashMap hm=new HashMap();
hm.put("1","zhangsan");
hm.put("2", "lisi");
hm.put("3","wangwu");
hm.put("4","zhaoliu");
//System.out.println(hm.containsKey("2"));
//System.out.println(hm.isEmpty());
//System.out.println(hm.remove("6"));
//System.out.println(hm.size());
Set set =hm.keySet();
Iterator it=set.iterator();
while (it.hasNext()) {
System.out.println(hm.get(it.next()));
}
}
HashMap Hashtable treeMap区别:
(1)HashMap线程不安全,无序,允许Key值出现一次null,Value值允许Null;
(2)Hashtable线程安全,无序,不仅实现了Map接口,也实现了Dictionary接口,Key值与Value值不允许为null;
(3)treeMap线程不安全,默认按照键的自然顺序进行升序排序,Key不允许null,Value值允许Null;
泛型
通过泛型替代定义不明确的参数类型。
泛型的本质是参数化类型,是将类的类型参数化,具体调用的时候再给具体的类型,这种参数类型可以用在类,接口和方法的创建中,分别称为泛型类,泛型接口,泛型方法。
泛型类:public class 类名{}
泛型接口:public interface 接口名{}
泛型方法:public 返回值类型 方法名(){}
public class FanXing {
public static <T> void fun(T t) {
System.out.println("传入的参数类型是"+t.getClass());
}
public static void main(String[] args) {
Generics<String> gs=new Generics<String>();
gs.add("hello");
gs.add("world");
gs.show();
fun("assd");
}
}
public interface GenDao<T> {
public void add(T t);
}
public class Generics<T> {
//保存任意类型的集合
ArrayList<T> al=new ArrayList<T>();
public void add(T t) {
al.add(t);
}
public void show() {
for (T t : al) {
System.out.println(t);
}
}
}
下一章节:JavaSE多线程(JavaSE大全)