前言：
1.为什么要使用集合？
以前我们存储对象的时候可以使用数组，但是数组的长度是固定的，我们不知道需要多大的数组，太小了不够用，多了又浪费资源，这时候集合就出现了。
2.和数组的区别？
- 数组的长度不可变，集合的长度可变。
- 数组可以存放基本类型和引用类型，集合只能存放引用类型
- 数组只能存放单一类型，集合在不规定泛型的情况下可以存放多种类型
Collection体系集合
Collection父接口：
方法：
- boolean add(Object obj) //添加一个对象。
- boolean addAll(Collection c) //讲一个集合中的所有对象添加到此集合中。
- void clear() //清空此集合中的所有对象。
- boolean contains(Object o) //检查此集合中是否包含o对象。
- boolean equals(Object o) //比较此集合是否与指定对象相等。
- boolean isEmpty() //判断此集合是否为空。
- boolean remove(Object o) //在此集合中移除o对象。
- int size() //返回此集合中的元素个数。
- Object[] toArray() //姜此集合转换成数组。
使用：
学生类：
public class XueSheng {
private int nianLing;
private char sex;
private String name;
public XueSheng(){}
public XueSheng(int nianLing,char sex,String name){
this.name = name;
this.nianLing = nianLing;
this.sex = sex;
}
public int getNianLing() {
return nianLing;
}
public void setNianLing(int nianLing) {
this.nianLing = nianLing;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "XueSheng{" +
"nianLing=" + nianLing +
", sex=" + sex +
", name='" + name + '\'' +
'}';
}
}Collection接口
public static void main(String[] args){
XueSheng xueSheng = new XueSheng(18,'男',"孟郊");
XueSheng xueSheng2 = new XueSheng(18,'男',"王维");
XueSheng xueSheng3 = new XueSheng(18,'男',"杜甫");
XueSheng xueSheng4 = new XueSheng(18,'男',"白居易");
//创建集合
Collection collection = new ArrayList();
// 1.添加元素
collection.add(xueSheng);
collection.add(xueSheng2);
collection.add(xueSheng3);
collection.add(xueSheng4);
System.out.println("元素个数："+collection.size());
//2.删除元素
collection.remove("西瓜");
System.out.println("删除后剩余元素："+collection.size());
//3.使用 foreach遍历
for (Object o : collection) {
System.out.println(o);
}
//3.2 使用迭代器（迭代器专门用来遍历集合的一种方式）
//hasnext();判断是否有下一个元素
//next();获取下一个元素
//remove();删除当前元素
Iterator iterator=collection.iterator();
while(iterator.hasNext()) {
XueSheng object = (XueSheng) iterator.next();
System.out.println(object);
//删除操作
//collection.remove(s);引发错误：并发修改异常
//iterator.remove();应使用迭代器的删除方法
}
// * 4.判断
System.out.println(collection.contains(xueSheng));//true
System.out.println(collection.isEmpty());//false
}Collection子接口 List接口
特点：
有序、有下标、元素可以重复。方法
- void add(int index,Object o) //在index位置插入对象o。
- boolean addAll(index,Collection c) //将一个集合中的元素添加到此集合中的index位置。
- Object get(int index) //返回集合中指定位置的元素。
- List subList(int fromIndex,int toIndex) //返回fromIndex和toIndex之间的集合元素。
List接口使用1：
//list接口 特点： 有序、有下标、元素可以重复 继承自Collection
public class List接口 {
public static void main(String []ar){
XueSheng xueSheng = new XueSheng(18,'男',"孟郊");
XueSheng xueSheng2 = new XueSheng(18,'男',"王维");
XueSheng xueSheng3 = new XueSheng(18,'男',"杜甫");
XueSheng xueSheng4 = new XueSheng(18,'男',"白居易");
List list = new ArrayList();
list.add(xueSheng);
list.add(xueSheng2);
list.add(xueSheng3);
list.add(0,xueSheng4); //指定位置插入元素
list.add("奥里给");
System.out.println("元素个数："+list.size());
list.remove(1);
// list.remove(xueSheng); //结果同上
System.out.println("元素个数："+list.size());
System.out.println(list.toString());
//1.使用普通for遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//2.使用foreach遍历
for (Object o : list) {
System.out.println(o);
}
//3 使用迭代器
Iterator iterator=list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
//4使用列表迭代器，listIterator可以双向遍历，添加、删除及修改元素。
ListIterator listIterator=list.listIterator();
//从前往后
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}
//从后往前（此时“遍历指针”已经指向末尾）
while(listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
//4.判断
System.out.println(list.isEmpty());
System.out.println(list.contains(xueSheng3));
//5.获取位置
System.out.println(list.indexOf(xueSheng3));
}
}List接口使用2：
public class List接口2 {
public static void main(String[] args) {
List list=new ArrayList();
//1.添加数字数据（自动装箱）
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println("元素个数："+list.size());
System.out.println(list.toString());
//2.删除元素
list.remove(0);
//list.remove(20);很明显数组越界错误，改成如下
//list.remove(Object(20));
//list.remove(new Integer(20));
System.out.println("元素个数："+list.size());
System.out.println(list.toString());
//3-5不再演示，与之前类似
//6.补充方法subList，返回子集合，含头不含尾
List list2=list.subList(1, 3);
System.out.println(list2.toString());
}
}List实现类：ArrayList
特点：
- 数组结构实现，查询块、增删慢；
- JDK1.2版本出现，运行效率快、线程不安全
//ArrayList 存储结构 数组 特点：查找遍历速度快，增删慢
public class List实现类ArrayList {
public static void main(String[] args) {
List arrayList=new ArrayList<>();
//1.添加元素
XueSheng s1 = new XueSheng(18,'男',"丁晓铎");
XueSheng s2 = new XueSheng(18,'男',"王维");
XueSheng s3 = new XueSheng(18,'男',"杜甫");
XueSheng s4 = new XueSheng(18,'男',"白居易");
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
arrayList.add(s4);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList.toString());
//2.删除元素
arrayList.remove(s1);
//arrayList.remove(new Student("唐", 21));
//注：这样可以删除吗（不可以）？显然这是两个不同的对象。
//假如两个对象属性相同便认为其是同一对象，那么如何修改代码？
//重写equals方法
//3.遍历元素
//3.1使用迭代器
Iterator iterator=arrayList.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
//3.2使用列表迭代器
ListIterator listIterator=arrayList.listIterator();
//从前往后遍历
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
//从后往前遍历
while(listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
//4.判断
System.out.println(arrayList.isEmpty());
//System.out.println(arrayList.contains(new XueSheng(18,'男',"孟郊"))); //需要XueSheng类重写Equals方法
//注：与上文相同的问题。
//5.查找
System.out.println(arrayList.indexOf(s1));
}
}修改后的学生类
public class XueSheng {
private int nianLing;
private char sex;
private String name;
public XueSheng(){}
public XueSheng(int nianLing,char sex,String name){
this.name = name;
this.nianLing = nianLing;
this.sex = sex;
}
public int getNianLing() {
return nianLing;
}
public void setNianLing(int nianLing) {
this.nianLing = nianLing;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "XueSheng{" +
"nianLing=" + nianLing +
", sex=" + sex +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object obj) {
//1.是否为同一对象
if (this==obj) {
return true;
}
//2.判断是否为空
if (obj==null) {
return false;
}
//3.判断是否是Student类型
if (obj instanceof XueSheng) {
XueSheng student=(XueSheng) obj;
//4.比较属性
if(this.name.equals(student.getName())&&this.nianLing==student.nianLing) {
return true;
}
}
//不满足，返回false
return false;
}
}ArrayList源码分析
- 默认容量大小：private static final int DEFAULT_CAPACITY = 10;
- 存放元素的数组：transient Object[] elementData;
- 实际元素个数：private int size;
Vector
特点：
数组结构实现，查询快、增删慢；
JDK1.0版本出现，运行效率慢、线程安全
public class List实现类Vector {
public static void main(String[]args){
Vector vector = new Vector();
vector.add("苹果");
vector.add("葡萄");
vector.add("菠萝");
vector.add("柠檬");
System.out.println("当前元素个数："+vector.size());
//删除数据
// vector.remove("菠萝");
// vector.remove(0);
// vector.clear();//删除所有
System.out.println(vector.toString());
//1.使用vector特有的枚举遍历器 因为他有下标 for foreach 迭代器都可以用
Enumeration enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
String s = (String) enumeration.nextElement();
System.out.println(s);
}
//4.判断
System.out.println(vector.isEmpty());
System.out.println(vector.contains("菠萝"));
//5. Vector其他方法
//firstElement() lastElement() ElementAt();
}
}LinkedList
特点
链表结构实现，增删快，查询慢。
public class List实现类LinkedList {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList<>();
XueSheng xueSheng1 = new XueSheng(19,'男',"杜甫");
XueSheng xueSheng2 = new XueSheng(19,'男',"李白");
XueSheng xueSheng3 = new XueSheng(19,'男',"王维");
XueSheng xueSheng4 = new XueSheng(19,'男',"孟郊");
linkedList.add(xueSheng1);
linkedList.add(xueSheng2);
linkedList.add(xueSheng3);
linkedList.add(xueSheng4);
System.out.println("元素个数："+linkedList.size());
System.out.println(linkedList.toString());
//删除元素
linkedList.remove(xueSheng1);
System.out.println(linkedList.toString());
//遍历
//1.for
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
//2.foreach
for (Object o : linkedList) {
System.out.println(o);
}
//3.3 使用迭代器
Iterator iterator =linkedList.iterator();
while (iterator.hasNext()) {
XueSheng xueSheng = (XueSheng) iterator.next();
System.out.println(xueSheng.toString());
}
//3.4 使用列表迭代器（略）
//4. 判断
System.out.println(linkedList.contains(xueSheng1));
System.out.println(linkedList.isEmpty());
System.out.println(linkedList.indexOf(xueSheng3));
}
}ArrayList和LinkedList区别
- ArrayList：必须开辟连续空间，查询快，增删慢。
- LinkedList：无需开辟连续空间，查询慢，增删快。
Collection子接口Set
- 特点：无序、无下标、元素不可重复。
- 方法：全部继承自Collection中的方法。
//Set接口 特定：无序 无下标 不能重复 继承自Collection接口
public class Set接口 {
public static void main(String[]args){
//创建集合
Set<String> set = new HashSet();
set.add("臭豆腐");
set.add("腐乳");
set.add("加六九");
set.add("你看这汉堡做的行不行?");
System.out.println(set.toString()); //可以看到是无序的
//删除数据
set.remove("你看这汉堡做的行不行?");
System.out.println(set.toString());
//遍历：foreach
for (String s : set) {
System.out.println(s);
}
//迭代器
System.out.println("*******************");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println(set.contains("腐乳"));
System.out.println(set.isEmpty());
}
}Set实现类HashSet
- 基于HashCode计算元素存放位置。
- 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
人类
public class Person{
private String name;
private int 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 String toString() {
return "Peerson [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);
}
}
}/*
基于HashCode计算元素存放位置。
当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
* 存储结构：哈希表（数组+链表+红黑树）
hashSet存储过程：
根据hashCode计算保存的位置，如果位置为空，则直接保存，否则执行第二步。
执行equals方法，如果方法返回true，则认为是重复，拒绝存储，否则形成链表。
*/
public class Set实现类HashSet {
public static void main(String[] args) {
HashSet<Person> hashSet=new HashSet<>();
Person p1=new Person("张三",21);
Person p2=new Person("李四", 22);
Person p3=new Person("王五", 21);
//1.添加元素
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
//重复，添加失败
hashSet.add(p3);
//直接new一个相同属性的对象，依然会被添加，不难理解。
//假如相同属性便认为是同一个对象，怎么修改？
//需要重写 equals 和hashCode
hashSet.add(new Person("张三", 21));
System.out.println(hashSet.toString());
//2.删除元素
hashSet.remove(p2);
//3.遍历
//3.1 增强for
for (Person person : hashSet) {
System.out.println(person);
}
//3.2 迭代器
Iterator<Person> iterator=hashSet.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
//4.判断
System.out.println(hashSet.isEmpty());
//直接new一个相同属性的对象结果输出是false，不难理解。
//注：假如相同属性便认为是同一个对象，该怎么做？
System.out.println(hashSet.contains(new Person("tang", 21)));
}
}TreeSet
- 基于排序顺序实现不重复。
- 实现了SortedSet接口，对集合元素自动排序。
- 元素对象的类型必须实现Comparable接口，指定排序规则。
- 通过CompareTo方法确定是否为重复元素。
public class Set实现类TreeSet {
public static void main(String[] args) {
TreeSet<Person> persons=new TreeSet<>();
Person p1=new Person("张三",21);
Person p2=new Person("李四", 22);
Person p3=new Person("王五", 21);
//1.添加元素
persons.add(p1);
persons.add(p2);
persons.add(p3);
//注：直接添加会报类型转换错误，需要实现Comparable接口
System.out.println(persons.toString());
//2.删除元素
persons.remove(p1);
persons.remove(new Person("张三", 22));
System.out.println(persons.toString());
//3.遍历
for (Person person : persons) {
System.out.println(person.getName()+":"+person.getAge());
}
System.out.println("---------------------");
Iterator<Person> iterator = persons.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//4.判断
System.out.println(persons.contains(p2));
}
}实现Comparable接口后的人类
public class Person implements Comparable<Person>{
private String name;
private int 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 String toString() {
return "Peerson [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);
}
//1.先按姓名比
//2.再按年龄比
public int compareTo(Person o) {
int n1=this.getName().compareTo(o.getName());
int n2=this.age-o.getAge();
return n1==0?n2:n1;
}
}除了实现Comparable接口里的比较方法，TreeSet也提供了一个带比较器Comparator的构造方法，使用匿名内部类来实现它：
public static void main(String[] args) {
TreeSet<Person> persons=new TreeSet<Person>(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("tang",21);
Person p2=new Person("he", 22);
Person p3=new Person("yu", 21);
persons.add(p1);
persons.add(p2);
persons.add(p3);
System.out.println(persons.toString());
}小案例：
/*
* 要求：使用TreeSet集合实现字符串按照长度进行排序
* helloworld tangrui hechengyang wangzixu yuguoming
* Comparator接口实现定制比较
*/
public class Set实现类TreeSetDemo {
public static void main(String[] args) {
TreeSet<String> treeSet=new TreeSet<String>(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;
}
});
treeSet.add("helloworld");
treeSet.add("tangrui");
treeSet.add("hechenyang");
treeSet.add("yuguoming");
treeSet.add("wangzixu");
System.out.println(treeSet.toString());
//输出[tangrui, wangzixu, yuguoming, hechenyang, helloworld]
}
}Map体系集合
Map接口的特点：
- 用于存储任意键值对(Key-Value)。
- 键：无序、无下标、不允许重复（唯一）。
- 值：无序、无下标、允许重复。
方法：
- V put(K key,V value)//将对象存入到集合中，关联键值。key重复则覆盖原值。
- Object get(Object key)//根据键获取相应的值。
- Set//返回所有的key
- Collection values()//返回包含所有值的Collection集合。
- Set<Map.Entry<K,V>>//键值匹配的set集合
public class Map接口 {
public static void main(String[] args) {
Map<String,String> maps = new HashMap<>();
maps.put("cn","中国");
maps.put("usa","美国");
maps.put("uk","英国");
maps.put("rb","日本");
// maps.put("cn","中国"); //无法添加重复的键
System.out.println("元素的个数："+maps.size());
System.out.println(maps.toString());
//删除
maps.remove("rb");
//遍历
//使用 keySet() 获取所有K 然后通过 k找到V
Set<String> strings = maps.keySet();
for (String string : strings) {
System.out.println(string+": "+maps.get(string));
}
System.out.println("---------------------------");
//使用 entrySet() 获取一个entry 里面存放着K V
Set<Map.Entry<String, String>> entries = maps.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
//判断
System.out.println(maps.containsKey("cn")); //判断K是否存在
System.out.println( maps.containsValue("意大利")); //判断V是否存在
}
}Map集合的实现类
HashMap【重点】
JDK1.2版本出现，线程不安全，运行效率快；允许用null作为key或是value。
/**
* 学生类
*/
public class Student {
private String name;
private int id;
public Student(String name, int id) {
super();
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + id + "]";
}
}public class Map实现类HashMap {
public static void main(String[] args) {
HashMap<Student,String> hashMaps = new HashMap<>();
//添加元素
HashMap<Student, String> hashMap=new HashMap<Student, String>();
Student s1=new Student("tang", 36);
Student s2=new Student("yu", 101);
Student s3=new Student("he", 10);
//1.添加元素
hashMap.put(s1, "成都");
hashMap.put(s2, "杭州");
hashMap.put(s3, "郑州");
hashMap.put(null, null);
//添加失败，但会更新值
hashMap.put(s3,"上海");
//添加成功，不过两个属性一模一样；
//注：假如相同属性便认为是同一个对象，怎么修改？
//重写 hashcode和equals
hashMap.put(new Student("he", 10),"上海");
System.out.println(hashMap.toString());
//2.删除元素
hashMap.remove(s3);
System.out.println(hashMap.toString());
//3.遍历
//3.1 使用keySet()遍历
for (Student key : hashMap.keySet()) {
System.out.println(key+" "+hashMap.get(key));
}
System.out.println("------------------------------");
//3.2 使用entrySet()遍历
for (Map.Entry<Student, String> entry : hashMap.entrySet()) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
//4.判断
//注：同上
System.out.println(hashMap.containsKey(new Student("yu", 101)));
System.out.println(hashMap.containsValue("成都"));
}和之前说过的HashSet类似，重复的依据是根据hashCode和equals方法，重写即可：
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}HashMap源码分析
- 默认初始化容量：static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
- 数组最大容量：static final int MAXIMUM_CAPACITY = 1 << 30;
- 默认加载因子：static final float DEFAULT_LOAD_FACTOR = 0.75f;
- 链表调整为红黑树的链表长度阈值（JDK1.8）：static final int TREEIFY_THRESHOLD = 8;
- 红黑树调整为链表的链表长度阈值（JDK1.8）：static final int UNTREEIFY_THRESHOLD = 6;
- 链表调整为红黑树的数组最小阈值（JDK1.8）：static final int MIN_TREEIFY_CAPACITY = 64;
- HashMap存储的数组：transient Node<K,V>[] table;
- HashMap存储的元素个数：transient int size;
TreeMap
实现了SortedMap接口（是Map的子接口），可以对key自动排序
在学生类中实现Comparable接口
public class Student implements Comparable<Student>{
@Override
public int compareTo(Student o) {
int n1=this.id-o.id;
return n1;
}/*
* TreeMap的使用
* 存储结构：红黑树
*/
public class Map实现类TreeMap {
public static void main(String[] args) {
TreeMap<Student, Integer> treeMap=new TreeMap<Student, Integer>();
Student s1=new Student("tang", 36);
Student s2=new Student("yu", 101);
Student s3=new Student("he", 10);
//1.添加元素
treeMap.put(s1, 21);
treeMap.put(s2, 22);
treeMap.put(s3, 21);
//不能直接打印，需要实现Comparable接口，因为红黑树需要比较大小
System.out.println(treeMap.toString());
//2.删除元素
treeMap.remove(new Student("he", 10));
System.out.println(treeMap.toString());
//3.遍历
//3.1 使用keySet()
for (Student key : treeMap.keySet()) {
System.out.println(key+" "+treeMap.get(key));
}
//3.2 使用entrySet()
for (Map.Entry<Student, Integer> entry : treeMap.entrySet()) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
//4.判断
System.out.println(treeMap.containsKey(s1));
System.out.println(treeMap.isEmpty());
}
}Collections工具类
概念：集合工具类，定义了除了存取以外的集合常用方法。
方法：
- public static void reverse(List<?> list)//反转集合中元素的顺序
- public static void shuffle(List<?> list)//随机重置集合元素的顺序
- public static void sort(List list)//升序排序（元素类型必须实现Comparable接口）
public class Collections工具类 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(20);
list.add(10);
list.add(30);
list.add(90);
list.add(70);
//sort排序
System.out.println(list.toString());
Collections.sort(list);
System.out.println("排序后---------");
System.out.println(list.toString());
System.out.println("二分查找10的下标---------");
//binarySearch二分查找
int i=Collections.binarySearch(list, 10);
System.out.println(i);
//copy复制
List<Integer> list2=new ArrayList<Integer>();
for(int i1=0;i1<5;++i1) {
list2.add(0);
}
//该方法要求目标元素容量大于等于源目标
Collections.copy(list2, list);
System.out.println("复制---------");
System.out.println(list2.toString());
//reserve反转
Collections.reverse(list2);
System.out.println("反转---------");
System.out.println(list2.toString());
//shuffle 打乱
Collections.shuffle(list2);
System.out.println("打乱---------");
System.out.println(list2.toString());
//补充：list转成数组
Integer[] arr=list.toArray(new Integer[0]);
System.out.println(arr.length);
//补充：数组转成集合
String[] nameStrings= {"tang","he","yu"};
//受限集合，不能添加和删除
List<String> list3= Arrays.asList(nameStrings);
System.out.println(list3);
//注：基本类型转成集合时需要修改为包装类
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
