目录
/*
集合框架:
底层:
子类集合【孙子辈】: 【1】Vector集合 【1】ArrayList集合 【1】LinkedList集合 【2】TreeSet集合 【2】HashSet集合 【2】LinkedHashSet集合
顶层:
子辈接口1 List接口:1 有序的集合【存储与去除元素顺序相同】
2 允许重复元素
3 存在索引,可以使用for循环遍历
子辈接口2 Set接口:1 不允许重复元素
2 没有索引,不允许for循环遍历
3 无序集合【除了最后一个集合】
父辈接口 Collection接口:
1 定义的是所有单列集合的共性方法
2 所有单列集合都可以使用共性方法
3 没有带索引的方法
Iterator迭代器:通用的遍历集合取出元素方式。
*/
1、Collcetion集合
/*
* java.util.Collection
* 1 共性的方法:1.1 public boolean add(E e): 把给定的对象添加到集合中
* 返回值是boolean值,一般不用接收,因为没有什么意义
* 1.2 public void clear():清空集合中的元素
* 1.3 public boolean remove(E e): 把给定的对象在当前集合中删除
* 返回值是boolean值,集合中存在元素,删除然后返回true,没有这个元素,删除失败返回false
* 1.4 public boolean contains(E e):判断当前集合是否包含给定对象
* 返回值是boolean值,包含返回true,不包含返回false
* 1.5 public boolean isEmpty():判断当前集合是否为空
* 返回值是boolean值,为空返回true,不为空返回false
* 1.6 public int size():返回集合中元素的个数
* 1.7 public Object[] toArray():把集合中的元素,存储到数组中。
2、Collection类
public static <T> boolean addAll(Collection<T> c,...elements) 往集合添加多个元素
public static void shuffle(List<?> list) 打乱集合中的元素顺序
public static <T> void sort(List<T> list) 将集合中的元素按默认顺序排序 默认升序
public static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。
* */
public class Collection_01 {
public static void main(String[] args) {
Collection<String> coll=new ArrayList<>();//多态 创建对象[子类随便改]
System.out.println(coll);//[] 不是地址值,说明重写了toString方法
//1.1 添加
boolean b1=coll.add("张三");
//System.out.println(b1);//true 一般返回true,又不是我们想要的值,所以接受没有意义
System.out.println(coll);//[张三]
coll.add("李四");
coll.add("赵六");
coll.add("王五");
coll.add("田七");
System.out.println(coll);//[张三, 李四, 赵六, 王五, 田七]
//1.3 删除
boolean b2=coll.remove("赵四");
boolean b3=coll.remove("张三");
System.out.println(b2);//false
System.out.println(b3);//true
System.out.println(coll);//[李四, 赵六, 王五, 田七]
//1.4 包含
boolean b4=coll.contains("赵四");
System.out.println(b4);//false
//1.5 当前集合是否为空
boolean b6 = coll.isEmpty();
System.out.println(b6);//false
//1.6 元素个数
int size=coll.size();
System.out.println(size);//4
//1.7 把集合中的元素存储到数组
Object[] arr=coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);//李四赵六王五田七
}
System.out.println("\n");
//1.2 清空集合所有元素
coll.clear();
System.out.println(coll);//[]
}
}
/*
java.util.Collections
* public static <T> void sort(List<T> list) 将集合中的元素按默认顺序排序 默认升序
注意:被排序的集合必须实现Comparable接口,重写接口的方法compare To定义排序的规则
排序规则:Comparable接口的排序规则:
自己(this)-参数;升序 反过来就是降序
return this.getAge()-person.getAge();//按年领升序排序
public static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。
* Comparable与Comparator的区别:
* Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则
* Comparator:相当于找一个第三方当裁判,比较这两个
* Comparator排序规则:return i1-i2;//升序
return i2-i1;//降序
* */
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person(String name, int age) {
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;
}
//重写排序的规则
@Override
public int compareTo(Person person) {
// return 0;//认为元素都是相同的
//自定义比较的规则,如:比较两个人的年领
return this.getAge()-person.getAge();//按年领升序排序
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Collections_lianxi_2 {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
Collections.sort(list, new Comparator<Integer>() {
//重写比较的规则
@Override
public int compare(Integer i1, Integer i2) {
//return i1-i2;//升序
return i2-i1;//降序
}
});
System.out.println(list);
ArrayList<Person> list1=new ArrayList<>();
list1.add(new Person("a迪丽热巴",18));
list1.add(new Person("古力娜扎",20));
list1.add(new Person("杨幂",17));
list1.add(new Person("b杨幂",18));
/*Collections.sort(list1, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge()-p2.getAge();//年领升序
}
});*/
Collections.sort(list1, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int result = o1.getAge() - o2.getAge();
//如果年领相等,比较姓名第一个字
if(result==0){
result=o1.getName().charAt(0)-o2.getName().charAt(0);
}
return result;
}
});
System.out.println(list1);
}
}
2、Map集合
/*Map集合
HashMap
Hashtable
Collection集合为单链集合,Map集合为双链集合
Map集合:
特点:1、一个元素包含两个值,由Key键和Value值组成
2、Key和Vaule的数据类型允许不同。
3、Key不允许重复,Value可以重复
4、Key与Value一一对应
常见子类:
java.util.HashMap集合 implements Map<k,v>
特点:1、查询速度快,底层为Hash表,无序
JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单项链表/红黑树【链表长度超过8时】
2、HashMap集合,存储元素与取出元素的顺序有可能不一致。
java.util.LinkHashMap集合 extends HashMap集合<k,v>集合
特点:1、底层是哈希表+链表【保证迭代顺序】 有序
2、LinkedHashMap集合是一个有序集合,存储元素和取出元素顺序一致。
1、 public V put(K key, V value) 把制定键与指定值添加到Map中
一般不接收返回值 V:存储键值对时,key不重复,返回null
key重复,使用新的value替换重复老key的value,返回老key的value
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。
2、public V remove(Object key) 从此映射中移除指定键的映射关系(如果存在)。
返回值V:key存在返回被删除的值
key不存在返回null
3、 public V get(Object key) 返回指定键所映射的值;如果对于该键来说,此映射不包含任何映射关系,则返回 null。
key存在,返回对应值
key不存在,返回null
4、 boolean containsKey(Object key) 判断集合是否包含指定键
包含返回true
不包含返回false
遍历: 通过键找值:
5、Set<K> keySet() 把map集合所有key取出来存储到set集合中
5.1 遍历set集合:迭代器;增强for
5.2 使用get方法通过key获取value
6、Map.Entry<K.V>:在Map集合中有一个内部接口Entry
作用:当Map集合已创建,就会自动创建一个Entry对象来记录键值对。
6.1 Set<Map.Entry<K,V>> entrySet() 将Map集合内部的多个Entry对象取出,存储到一个Set集合中
6.2 遍历Set集合获取每一个Entry对象
6.3 使用Map.Entry<K,V>里的方法:
K getKey() 返回与此项对应的键。
V getValue() 返回与此项对应的值。
Hashtable<K,V>集合,实现了Map接口,底层为哈希表
* 特点:1、不允许为空;【引用数据类型默认为空】
* 2、单线程
* Hashtable 底层是一个哈希表,线程安全,单线程,速度慢;
* HashMap 底层是一个哈希表,线程不安全,多线程,速度快;
* 在JDK1.2之后被HashMap取代,但他的子类Properties仍然使用,他是唯一一个和IO流结合的集合。
*/
/*Hashtable<K,V>集合,实现了Map接口,底层为哈希表
* 特点:1、不允许为空;【引用数据类型默认为空】
* 2、单线程
* Hashtable 底层是一个哈希表,线程安全,单线程,速度慢;
* HashMap 底层是一个哈希表,线程不安全,多线程,速度快;
* 在JDK1.2之后被HashMap取代,但他的子类Properties仍然使用,他是唯一一个和IO流结合的集合。
* HashMap存储自定义类型键值:
* Map集合保证Key值唯一,作为Key的元素,必须重写hashCode方法和equals方法,以保证key唯一。
* */
import java.util.Objects;
public class Person1 {
private String name;
private int age;
public Person1() {
}
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person1 person1 = (Person1) o;
return age == person1.age &&
Objects.equals(name, person1.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person1{" +
"name='" + name + '\'' +
", 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;
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Map_01lianxi {
public static void main(String[] args) {
show01();
show02();
}
// key:Person类型 必须重写hashCode和equals方法,以保证唯一性
// value:String 可以重复
private static void show02(){
HashMap<Person1,String> map=new HashMap<>();
map.put(new Person1("女王",18),"英国");
map.put(new Person1("秦始皇",108),"秦国");
map.put(new Person1("普京",18),"俄国");
map.put(new Person1("普京",18),"中国");//重写完hashCode和equals后,key重复的老value消失
//entryset+增强for
Set<Map.Entry<Person1, String>> set = map.entrySet();
for(Map.Entry<Person1,String> entry:set){
Person1 key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"=>"+value);
}
}
// =========================================================================
// key:String类型 ;String类重写hashCode方法和equals方法,以保证唯一性。
// value:Person1类型;可以重复
private static void show01() {
HashMap<String,Person1> map=new HashMap<>();
map.put("北京",new Person1("张三",18));
map.put("上海",new Person1("李四",19));
map.put("北京",new Person1("赵六",18));//key重复会让老的value替换新的value
//keyset+增强for遍历
Set<String> set = map.keySet();
for(String key:set) {
Person1 value = map.get(key);
System.out.println(key + "=>" + value);
}
}
}
3、HashSet
/*给HashSet集合存储自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的存储方式,才能保证HashSet对象唯一
哈希值:是一个十进制整数,由系统随机给出【就是对象的逻辑地址值,不是真实的物理地址】
在Object类有一个方法可以获取对象的哈希值
int hashCode() 返回该对象的哈希值
public native int hashCode();
native:代表该方法调用的是本地的操作系统的方法。
HashSet<String> set1=new HashSet<>();
set1.add("重地")
add方法调用“重地”【String】的hashCode方法,计算字符串“重地”的哈希值,比如哈希值是12346
然后就会找集合中有没有哈希值是12346的元素,发现没有
就会把“重地”存储到集合中 挂在哈希值为12346的位置上
set1.add("通话")
add方法调用“通话”的hashCode方法,计算字符串“a通话”的哈希值,为12346
然后就会找集合中有没有哈希值是12346的元素,发现有,即产生了哈希冲突
“通话”就会调用equals方法和哈希值相同的元素进行内容比较,"通话".equals("重地"),
返回false,两个元素内容不相同,就把“通话”存储到集合中。挂在哈希值为12346的位置上
*/
4、LinkedHashSet
/*
* java.util.LinkedHashSet集合 extends HashSet集合
* LinkedHashSet特点:
* 底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表结构(记录元素的存储顺序),保证元素有序
*
* */
import java.util.HashSet;
import java.util.LinkedHashSet;
public class LinkedHashSet_lianxi {
public static void main(String[] args) {
HashSet<String> set=new HashSet<>();
set.add("www");
set.add("aaa");
set.add("aaa");
set.add("itcast");
System.out.println(set);//[aaa, www, itcast] 无序,不允许重复
LinkedHashSet<String> linked=new LinkedHashSet<>();
linked.add("www");
linked.add("aaa");
linked.add("aaa");
linked.add("itcast");//[aaa, www, itcast] 有序,不允许重复
}
}