集合
概念：对象的容器，定义了多个对象进行操作的常用方法，类似数组功能
和数组的区别
1、数组长度固定，集合长度不固定
2、数组可以存储基本类型和引用类型，集合只能存储引用类型位置：java.util.*
Collection体系集合
Collection
- 特点：代表一组任意类型的对象，无序、无下标、不能重复
-
方法
- Collection的使用
student类
package Collection;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
迭代器（Iterator<E>）
hasNext（）：如果仍有元素可以迭代，则返回 true
next()：返回迭代的下一个元素。
Collection.Demo1
package Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Collection接口的使用
* 1、添加元素
* 2、删除元素
* 3、遍历元素
* 4、判断
*/
public class Demo01 {
public static void main(String[] args) {
//创建集合
Collection collection = new ArrayList();
// 添加元素
collection.add("苹果");
collection.add("西瓜");
collection.add("榴莲");
System.out.println("元素个数：" + collection.size());
System.out.println(collection);
// 删除元素
// collection.remove("榴莲");
// collection.clear(); //删除全部
// System.out.println("删除之后：" + collection.size());
// 遍历元素
System.out.println("3.1使用增强for");
for(Object object : collection){
System.out.println(object);
}
System.out.println("3.2使用迭代器(迭代器专门用来遍历集合的一种方式");
/*hasNext();有没有下一个元素
* next()获取下一个元素
* remove()删除当前元素
* 使用迭代器不能使用collection的其他方法：collection.remove()
* */
Iterator it = collection.iterator();
while(it.hasNext()){
String s = (String) it.next();
System.out.println(s);
//it.remove();
}
System.out.println("元素个数：" + collection.size());
// 判断
System.out.println(collection.contains("西瓜")); //true
System.out.println(collection.isEmpty()); //false
}
}
Collection.Demo2
package Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Collection的使用：保存学生信息
*
*/
public class Demo02 {
public static void main(String[] args) {
//新建Collection对象
Collection collection = new ArrayList();
Student s1 = new Student("张三",20);
Student s2 = new Student("阿狸",18);
Student s3 = new Student("王二",22);
//添加数据
collection.add(s1);
collection.add(s2);
collection.add(s3);
System.out.println("元素个数：" + collection.size());
System.out.println(collection.toString());
//删除
//collection.remove(new Student("王二",22)); //这样不能删除
//collection.clear(); //实际上是删除地址指针
System.out.println("删除之后：" + collection.size());
//遍历
System.out.println("for循环");
for(Object object : collection){
Student s = (Student) object;
System.out.println(s.toString());
}
System.out.println("迭代器");
Iterator it = collection.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s.toString());
}
//判断
System.out.println(collection.contains(s1));
System.out.println(collection.isEmpty());
}
}
Collection子接口
List集合
- 特点：有序、有下标、元素可以重复
-
方法：
- List的使用
ListIterator 方法更强大
hasNext()： 以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 <tt>next</tt> 返回一个元素而不是抛出异常，则返回true）。
hasPrevious()：如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
next()：返回列表中的下一个元素。
previous()：返回列表中的上一个元素。
Collection.Demo3
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* List的子接口的使用
* 特点：1、有序有下标 2、可以重复
*/
public class Demo3 {
public static void main(String[] args) {
//先创建集合对象
List list = new ArrayList();
// 添加元素
list.add("苹果");
list.add("小米");
list.add("华为");
System.out.println("元素个数：" + list.size());
System.out.println(list.toString());
//删除元素
// list.remove("苹果");
// list.remove(0);
// System.out.println("删除之后：" + list.size());
//遍历
System.out.println("----for循环----");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("----增强for----");
for(Object object : list){
System.out.println(object);
}
System.out.println("----迭代器----");
Iterator it = list.iterator();
while(it.hasNext()){
Object s = it.next();
System.out.println(s);
}
System.out.println("----列表迭代器-----");
/*
可向前遍历，也可以向后遍历 添加、删除、修改元素
*/
ListIterator lit = list.listIterator();
System.out.println("----从前往后");
while(lit.hasNext()){
System.out.println(lit.nextIndex() + ":" + lit.next());
}
System.out.println("----从后往前");
while(lit.hasPrevious()){
System.out.println(lit.previousIndex() + ":" + lit.previous());
}
// 判断
System.out.println(list.contains("苹果"));
System.out.println(list.isEmpty());
// 获取位置
System.out.println(list.indexOf("华为"));
}
}
Collection.Demo4
package Collection;
import java.util.ArrayList;
import java.util.List;
/**
* List的使用
*/
public class Demo4 {
public static void main(String[] args) {
List list = new ArrayList();
//添加数字数据（自动装箱)
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println("元素个数+"+list.size());
System.out.println(list.toString());
//删除
// list.remove(new Integer(20)); // 直接写20会被当成下标
// System.out.println(list.toString());
//补充方法subList 返回子集合，含头不含尾
List subList = list.subList(1, 3);
System.out.println(subList.toString());
}
}
List实现类
ArrayList、Vector、LinkedList对比
ArrayList
- ArrayList的使用
Collction.Demo5
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/**
* ArrayList的使用
* 存储结构：数组， 查找遍历速度快，增删慢
*/
public class Demo5 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
//添加
Student s1 = new Student("刘德华",20);
Student s2 = new Student("郭富城",22);
Student s3 = new Student("梁朝伟",23);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println("元素个数：" + arrayList.size());
System.out.println(arrayList.toString());
//删除
// arrayList.remove(s1);
// arrayList.remove(new Student("刘德华",20));
// System.out.println("删除后："+arrayList.toString()); // 重写student的equals方法，equals+enter就出来了
// 遍历元素
System.out.println("----迭代器----");
Iterator it = arrayList.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s.toString());
}
System.out.println("----列表迭代器----");
ListIterator lit = arrayList.listIterator();
System.out.println("----从前往后");
while(lit.hasNext()){
System.out.println(lit.nextIndex() + ":" + lit.next());
}
System.out.println("----从后往前");
while(lit.hasPrevious()){
System.out.println(lit.previousIndex() + ":" + lit.previous());
}
//判断
System.out.println(arrayList.contains(new Student("刘德华", 20)));
System.out.println(arrayList.isEmpty());
//查找
System.out.println(arrayList.indexOf(new Student("刘德华", 20)));
}
}
- ArrayList源码分析
- 默认容量：
private static final int DEFAULT_CAPACITY = 10;
添加元素后才有默认容量，没添加元素时，元素为0
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
- 存放容量的数组：Object[] elementData
- size：列表实际元素个数
- add()：添加元素
- grow()：oldCapacity >> 1 右移一位就是除以2 ，自动扩容为原来的1.5倍
Vector
- Vector的使用
Vector.Demo1
package Vector;
import java.beans.VetoableChangeListener;
import java.util.Enumeration;
import java.util.Vector;
/**
* Vector集合的使用
* 存储结构：数组
*/
public class Demo1 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("草莓");
vector.add("芒果");
vector.add("西瓜");
System.out.println("元素个数：" + vector.size());
System.out.println(vector.toString());
// vector.remove(0);
// vector.remove("西瓜");
// vector.clear();
// 遍历
Enumeration en = vector.elements();
while(en.hasMoreElements()){
String o =(String) en.nextElement();
System.out.println(o);
}
System.out.println(vector.contains("西瓜"));
System.out.println(vector.isEmpty());
// 其他方法
System.out.println(vector.firstElement());
System.out.println(vector.lastElement());
}
}
LinkedList
- LinkedList的使用
Collection.Demo6
package Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* LinkedList的使用
* 存储结构：双向链表
*/
public class Demo6 {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
Student s1 = new Student("刘德华",20);
Student s2 = new Student("郭富城",22);
Student s3 = new Student("梁朝伟",23);
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
System.out.println("元素个数：" + linkedList.size());
System.out.println(linkedList.toString());
// linkedList.remove(s1);
// linkedList.remove(new Student("刘德华",20));
// linkedList.clear();
// for遍历
System.out.println("----for循环----");
for(int i=0;i<linkedList.size();i++){
System.out.println(linkedList.get(i));
}
System.out.println("----增强for----");
for(Object s:linkedList){
System.out.println(s);
}
System.out.println("----迭代器----");
Iterator it = linkedList.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s);
}
System.out.println("----列表迭代器----");
ListIterator lit = linkedList.listIterator();
System.out.println("----从前往后");
while(lit.hasNext()){
System.out.println(lit.nextIndex() + ":" + lit.next());
}
System.out.println("----从后往前");
while(lit.hasPrevious()){
System.out.println(lit.previousIndex() + ":" + lit.previous());
}
// 判断
System.out.println(linkedList.contains(s1));
System.out.println(linkedList.isEmpty());
// 获取
System.out.println(linkedList.indexOf(s2));
}
}
- LinkedList源码分析
- int size：集合大小
- Node first：链表的头节点
- Node last：链表 的尾节点
Set集合
- 特点：无序、无下标、元素不可重复
- 方法：全部继承collection的方法
- Set接口的使用
Set.Demo1
package Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* 测试set接口的使用
* 特点：1、无序、无下标2、不能重复
*/
public class Demo1 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
//添加数据
set.add("华为");
set.add("苹果");
set.add("小米");
System.out.println(set.toString()); //打印是无序的
//删除
// set.remove("小米");
// System.out.println(set.toString());
// set.clear();
//遍历
System.out.println("----增强for----");
for(String s:set){
System.out.println(s);
}
System.out.println("----迭代器----");
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(set.contains("华为"));
System.out.println(set.isEmpty());
}
}
HashSet
- 基于HashCode计算元素存放位置。
- 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
Set.Demo2
package Set;
import java.util.HashSet;
import java.util.Iterator;
/**
* HashSet集合的使用
* 存储结构：哈希表（数组+链表+红黑树）
*/
public class Demo2 {
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<>();
//添加
hashSet.add("刘德华");
hashSet.add("梁朝伟");
hashSet.add("刘志玲");
hashSet.add("周润发");
System.out.println(hashSet.toString());
//删除
// hashSet.remove("刘德华");
// hashSet.clear();
//遍历
System.out.println("----增强for----");
for(String s:hashSet){
System.out.println(s);
}
System.out.println("----迭代器----");
Iterator<String> it = hashSet.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(hashSet.contains("华为"));
System.out.println(hashSet.isEmpty());
}
}
Set.Person
package Set;
import java.util.Objects;
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//先按姓名比，再按年龄比
@Override
public int compareTo(Person o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.age-o.getAge();
return n1==0?n2:n1;
}
}
Set.Demo3
package Set;
import java.util.HashSet;
/**
* hashSet的使用
* 存储结构：哈希表（数组+链表+红黑树）
* 存储过程：
* 1）根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步
* 2）再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
*/
public class Demo3 {
public static void main(String[] args) {
HashSet<Person> persons = new HashSet<>();
Person p1 = new Person("刘德华",20);
Person p2 = new Person("郭富城",22);
Person p3 = new Person("梁朝伟",23);
persons.add(p1);
persons.add(p2);
persons.add(p3);
//persons.add(p3) //不可以添加
persons.add(new Person("梁朝伟",23)); // 可以添加，重写equals和hashcode就不可以添加了
System.out.println(persons.toString());
// 删除
// persons.remove(p1);
// persons.remove(new Person("梁朝伟",23));
}
}
TreeSet
- 基于排列顺序实现元素不重复
- 实现类SortSet接口，对集合元素自动排序
- 元素对象的类型必须实现Comparable接口，指定排序规则
- 通过CompareTo方法确定是否为重复元素
Set.Demo4
package Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
/**
* TreeSet的使用
* 存储结构：红黑树
*/
public class Demo4 {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("xyz");
treeSet.add("abc");
treeSet.add("hello");
treeSet.add("xyz");
System.out.println(treeSet.toString());
//遍历
System.out.println("----增强for----");
for(String s:treeSet){
System.out.println(s);
}
System.out.println("----迭代器----");
Iterator<String> it = treeSet.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(treeSet.contains("abc"));
System.out.println(treeSet.isEmpty());
}
}
Set.Demo5
package Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
/**
* TreeSet保存数据
* 存储结构：红黑树
* 要求：元素必须实现Comparable接口,compareTo()的返回值为0，认为是重复元素
*/
public class Demo5 {
public static void main(String[] args) {
TreeSet<Person> persons = new TreeSet<>();
Person p1 = new Person("刘德华",20);
Person p2 = new Person("郭富城",22);
Person p3 = new Person("梁朝伟",23);
persons.add(p1);
persons.add(p2);
persons.add(p3);
//persons.add(p3) //不可以添加
persons.add(new Person("梁朝伟",23)); // 可以添加，重写equals和hashcode就不可以添加了
System.out.println(persons.toString());
// 删除
// persons.remove(p1);
// persons.remove(new Person("梁朝伟",23));
// System.out.println(persons.toString());
//遍历
System.out.println("----增强for----");
for(Person p:persons){
System.out.println(p);
}
System.out.println("----迭代器----");
Iterator<Person> it = persons.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(persons.contains(p1));
System.out.println(persons.isEmpty());
}
}
实现定制比较器
Set.Demo6
package Set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/**
* TreeSet保存数据
* Comparator:实现定制比较（比较器
* Comparable:可比较的
*/
public class Demo6 {
public static void main(String[] args) {
TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n1=o1.getAge()-o2.getAge();
int n2=o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Person p1 = new Person("刘德华",20);
Person p2 = new Person("郭富城",22);
Person p3 = new Person("梁朝伟",23);
persons.add(p1);
persons.add(p2);
persons.add(p3);
//persons.add(p3) //不可以添加
persons.add(new Person("梁朝伟",23)); // 可以添加，重写equals和hashcode就不可以添加了
System.out.println(persons.toString());
// 删除
// persons.remove(p1);
// persons.remove(new Person("梁朝伟",23));
// System.out.println(persons.toString());
//遍历
System.out.println("----增强for----");
for(Person p:persons){
System.out.println(p);
}
System.out.println("----迭代器----");
Iterator<Person> it = persons.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//判断
System.out.println(persons.contains(p1));
System.out.println(persons.isEmpty());
}
}
Set.Demo7
package Set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* 要求：使用TreeSet集合实现字符串按照长度进行排序
* helloworld zhang lisi wangwu beijing xian nanjing
*
*/
public class Demo7 {
public static void main(String[] args) {
//创建集合，制定比较规则
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int n1=o1.length()-o2.length();
int n2=o1.compareTo(o2);
return n1==0?n2:n1; //如果n1==0,证明长度相等则比较string
}
});
treeSet.add("helloword");
treeSet.add("pingguo");
treeSet.add("lisi");
treeSet.add("zhangsan");
treeSet.add("cat");
treeSet.add("nanjing");
treeSet.add("ali");
System.out.println(treeSet.toString());
}
}
Map集合
-
特点
1.用于存储任意键值对(Key-Value)。
2.键：无序、无下标、不允许重复（唯一）。
3.值：无序、无下标、允许重复。
Map父接口
- 特点：存储一对数据（key-value），无序、无下标，键不可以重复，值可以重复
-
方法：
-
Map的使用
map.keySet()：把所有的key拿出来放到Set集合里面（key和value分开遍历）
map.entrySet()：把key和value封装成一个个entry（效率高）
map.Demo1
package map;
import java.util.HashMap;
import java.util.Map;
/**
* Map接口的使用
* 特点：1、存储键值对 2、键不能重复，值可以 3、无序
*/
public class Demo1 {
public static void main(String[] args) {
//创建Map集合
Map<String,String> map = new HashMap<>();
map.put("cn", "中国");
map.put("uk","英国");
map.put("usa","美国");
map.put("cn","zhongguo"); //不能共存会把前面的替换掉
System.out.println(map.toString());
//删除
// map.remove("usa");
//遍历
System.out.println("----keySet()----");
// Set<String> keyset = map.keySet();
for(String key:map.keySet()){
System.out.println(key+":"+map.get(key));
}
System.out.println("-----entrySet()----");
// Set<Map.Entry<String,String>> entries = map.entrySet();
for(Map.Entry<String,String> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
System.out.println(map.containsKey("cn"));
System.out.println(map.containsValue("泰国"));
}
}
HashMap
- HashMap的使用
map.Student
package map;
import java.util.Objects;
public class Student {
private String name;
private int stuNo;
public Student() {
}
public Student(String name, int stuNo) {
this.name = name;
this.stuNo = stuNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStuNo() {
return stuNo;
}
public void setStuNo(int stuNo) {
this.stuNo = stuNo;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", stuNo=" + stuNo +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return stuNo == student.stuNo && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, stuNo);
}
}
map.Demo2
package map;
import java.util.HashMap;
import java.util.Map;
/**
* HashMap集合的使用
* 存储结构：哈希表（数组+链表+红黑树）
*/
public class Demo2 {
public static void main(String[] args) {
HashMap<Student,String> studens = new HashMap<>();
//刚创建HashMap table=null =>size=0
Student s1 = new Student("孙悟空",101);
Student s2 = new Student("猪八戒",102);
Student s3 = new Student("沙和尚",103);
studens.put(s1,"北京");
studens.put(s2,"上海");
studens.put(s3,"杭州");
System.out.println(studens.toString());
//删除
// studens.remove(s1);
//遍历
System.out.println("----keySet()----");
// Set<String> keyset = map.keySet();
for(Student key:studens.keySet()){
System.out.println(key+":"+studens.get(key));
}
System.out.println("-----entrySet()----");
// Set<Map.Entry<String,String>> entries = map.entrySet();
for(Map.Entry<Student,String> entry : studens.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
// 判断
System.out.println(studens.containsKey(new Student("孙悟空",101)));
System.out.println(studens.containsValue("上海"));
}
}
- HashMap的源码分析
-
初始大小为16(1<<4 : 1X2**4)
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 1 -
最大值为1<<30
static final int MAXIMUM_CAPACITY = 1 << 30; -
默认加载因子为0.75（容量使用超过75%就扩容）
static final float DEFAULT_LOAD_FACTOR = 0.75f; -
数组长度大于64，链表长度大于8，链表变成红黑树，链表长度小于6，调整为数组
static final int TREEIFY_THRESHOLD = 8; static final int UNTREEIFY_THRESHOLD = 6; static final int MIN_TREEIFY_CAPACITY = 64; HashMap存储的数组：transient Node<K,V>[] table;
HashMap存储的元素个数：transient int size;
-
HashSet实际上用的HashMap,它的方法add用的是HashMap的put
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
总结
1.HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调为16
2.当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的2倍，目的时减少调整元素的个数
3.jdk1.8当每个链表长度大于8，并且元素个数大于等于64时，会调整为红黑树，目的提高执行效率
4.jdk1.8当链表长度小于6时，调整成链表
5.jdk1.8以前，链表时头插入，jdk1.8之后是尾插入
TreeMap
- TreeSet的使用
map.Demo3
package map;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
/**
* TreeMap的使用
* 存储结构：红黑树
*/
public class Demo3 {
public static void main(String[] args) {
TreeMap<Student,String> treeMap = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int n1=o1.getName().compareTo(o2.getName());
int n2 = o1.getStuNo()-o2.getStuNo();
return n1==0?n2:n1;
}
});
Student s1 = new Student("孙悟空",101);
Student s2 = new Student("猪八戒",102);
Student s3 = new Student("沙和尚",103);
treeMap.put(s1,"北京");
treeMap.put(s2,"上海");
treeMap.put(s3,"杭州");
System.out.println(treeMap.toString());
// treeMap.remove(s3);
// treeMap.remove(new Student("孙悟空",101));
//遍历
System.out.println("----keySet()----");
// Set<String> keyset = map.keySet();
for(Student key:treeMap.keySet()){
System.out.println(key+":"+treeMap.get(key));
}
System.out.println("-----entrySet()----");
// Set<Map.Entry<String,String>> entries = map.entrySet();
for(Map.Entry<Student,String> entry : treeMap.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
// 判断
System.out.println(treeMap.containsKey(new Student("孙悟空",101)));
System.out.println(treeMap.containsValue("上海"));
}
}
Collections工具类
- 概念：集合工具类，定义除了存取以外的集合常用方法
-
方法：
image.png - Collections类的使用
map.Demo4
package map;
import java.util.*;
/**
* 演示Colletions工具类的使用
*/
public class Demo4 {
public static void main(String[] args) {
List<Integer> list= new ArrayList<>();
list.add(20);
list.add(5);
list.add(12);
list.add(30);
list.add(6);
System.out.println("排序之前:" + list.toString());
// sort排序
Collections.sort(list);
System.out.println("排序之后:" + list.toString());
//binarySearch
int i = Collections.binarySearch(list,12);
System.out.println(i);
//copy复制
List<Integer> dest = new ArrayList<>();
for(int k=0;k<list.size();k++){
dest.add(0);
}
Collections.copy(dest, list);
System.out.println(dest.toString());
//reverse反转
Collections.reverse(list);
System.out.println("反转之后：" + list.toString());
//shuffle 打乱
Collections.shuffle(list);
System.out.println("打乱之后：" + list);
//补充：list转数组 new的那个数组长度小于list的长度的话，arr的长度等于list的长度,否则是new数组的长度
Integer[] arr = list.toArray(new Integer[0]);
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));
//数组转集合
String[] name = {"张三","李四","王五"};
//集合是一个受限集合，不能添加删除
List<String> list2 = Arrays.asList(name);
System.out.println(list2.toString());
//基本类型数组转成集合时，需要修改为包装类 int=>Integer
Integer[] nums ={100,200,300,400,500};
List<Integer> list3 = Arrays.asList(nums);
}
}
集合总结
泛型
- Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递
- 常见形式有泛型类、泛型接口、泛型方法
- 好处
1、提高代码的重用性
2、防止类型转换异常，提高代码的安全性
泛型类
Generic.MyGeneric
package Generic;
/**
* 泛型类
* 语法：类名<T,E>
* T是类型占位符，表示一种引用类型，如果编写多个用逗号隔开
*/
public class MyGeneric<T> {
//使用泛型T
//1、创建遍历
T t;
//2、作为方法的参数
public void show(T t){
System.out.println(t);
}
//3、使用泛型作为方法的返回值
public T getT(){
return t;
}
}
Generic.TestGeneric 部分代码
//使用泛型类创建对象
MyGeneric<String> myGeneric = new MyGeneric<String>();
myGeneric.t = "hello";
myGeneric.show("大家好，加油");
System.out.println(myGeneric.getT());
MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
myGeneric2.t = 10;
myGeneric2.show(20);
System.out.println(myGeneric2.getT());
- 泛型只能使用引用类型
- 不同泛型对象不能相互复制（错误： MyGeneric<String> myGeneric3 = myGeneric2;）
泛型接口
Generic.MyInterface
package Generic;
/**
* 泛型接口
* 语法：接口名<T>
*注意:不能泛型静态常量
*/
public interface MyInterface <T> {
String name = "张三";
T sever(T t);
}
- 在实现类的时候确定类型
Generic.MyInterfaceImpl
package Generic;
public class MyInterfaceImpl implements MyInterface<String>{
@Override
public String sever(String s) {
System.out.println(s);
return s;
}
}
Generic.TestGeneric 部分代码
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.sever("阿狸");
- 实现类也是泛型类，在创建对象时确定类型
Generic.MyInterfaceImpl2
public class MyInterfaceImpl2<T> implements MyInterface<T>{
@Override
public T sever(T t) {
System.out.println(t);
return t;
}
}
Generic.TestGeneric 部分代码
MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<Integer>();
impl2.sever(10);
泛型方法
可以放在参数可以放在返回值，类型由传递值决定
Generic.MyGenericMethod
package Generic;
/**
* 泛型方法
* 语法：<T>返回值类型
*/
public class MyGenericMethod {
//泛型方法
public <T> T show(T t){
System.out.println("泛型方法"+t);
return t;
}
}
Generic.TestGeneric 部分代码
//泛型方法的使用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("中国加油");
myGenericMethod.show(200);
myGenericMethod.show(3.14);
泛型集合
- 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
- 特点：
1、编译时即可检查，而非运行时抛出异常。
2、访问时，不必类型转换（拆箱）。
3、不同泛型指尖引用不能相互赋值，泛型不存在多态。
