JAVA集合
- 对象的容器，定义了对多个对象进行操作的方法。可以实现数组功能
- 集合数组的区别
- 数组长度固定，集合长度不定
- 数组可以存储基本类型和引用类型，集合只能存储引用类型
Collection体系集合
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-El74aTrt-1648795945437)(D:\笔记\JAVA集合框架\photo\IMG_1282(20220325-162137)].PNG)
Collection父接口
-
使用
//collection保存字符串 import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo { public static void main(String[] args) { //创建集合 Collection collection=new ArrayList(); //添加 collection.add("西瓜"); collection.add("香蕉"); collection.add("香蕉2"); System.out.println("元素个数"+collection.size()); System.out.println(collection); //删除元素 collection.remove("香蕉"); System.out.println("删除之后元素个数"+collection.size()); //遍历 System.out.println("增强for"); for (Object object:collection){//快捷键forea System.out.println(object); } System.out.println("迭代器"); //迭代器，专门用来遍历集合的一种方式 //Iterator 迭代器 //hasNext() 有没有下一个元素 //next() 获取下一个元素 //remove() 删除当前元素 Iterator it=collection.iterator(); while (it.hasNext()){//Object类型 String s=(String)it.next(); System.out.println(s); //迭代过程不允许使用collection.remove()删除 // it.remove();//可以使用 } collection.contains("");//判断是否存在 collection.isEmpty();//判断是否为空，为空true } } -
Man类使用
package com.wly.Dome; public class Man { private String name; private int age; public Man(String name, int age){ this.name=name; this.age=age; } @Override public String toString() { return "Man{" + "name='" + name + '\'' + ", age=" + age + '}'; } }package com.wly.Dome; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; //collection保存表 public class Demo { public static void main(String[] args) { Collection collection=new ArrayList(); Man m1=new Man("张三",20); Man m2=new Man("李四",30); Man m3=new Man("王五",30); //添加数据 collection.add(m1); collection.add(m2); collection.add(m3); collection.add(m1); System.out.println(collection.size()); System.out.println(collection.toString()); //删除 // collection.remove(m3);//equals方法（this=obj） // collection.remove(); System.out.println(collection.size()); System.out.println(collection.toString()); //清除,清除集合里的地址 // collection.clear(); //遍历 System.out.println("==============="); for(Object object:collection){ Man man=(Man) object; System.out.println(man.toString()); } System.out.println("==============="); //迭代 Iterator it=collection.iterator(); while (it.hasNext()){ Man man=(Man) it.next(); System.out.println(man.toString()); } //判断 System.out.println(collection.contains(m1)); } }
List子接口
List接口及使用:
-
package com.wly.Dome; import java.util.*; //collection保存表 public class Demo { public static void main(String[] args) { //创建List集合，有序，有下标，可以重复 List list=new ArrayList<>(); //添加元素 list.add("苹果"); list.add(1,"华为"); list.add(0,"小米"); list.add("诺基亚"); System.out.println(list); System.out.println("元素个数"+list.size()); System.out.println("第一个元素为:"+list.get(0)); //删除 list.remove("华为");//根据角标删除 System.out.println(list.toString()); //通过for下标遍历 for (int i = 0; i <list.size() ; i++) { System.out.println(list.get(i)); } //通过增强for for (Object object:list) { System.out.println(object); } //通过迭代器 Iterator it=list.iterator(); while (it.hasNext()){ System.out.println(it.next()); } //列表迭代器,可以向前向后遍历，添加，删除，修改 System.out.println("列表迭代器"); ListIterator li=list.listIterator(); li.add("opp"); while (li.hasNext()){//从前向后遍历 System.out.println(li.nextIndex()+":"+li.next());//返回后一个调用索引：返回下一个元素 } while (li.hasPrevious() ){//从后向前遍历，在has.Next()基础上调整指针位置 System.out.println(li.previousIndex()+":"+li.previous());//返回前一个调用索引：返回前一个元素 } //判断 System.out.println(list.contains("苹果"));//判断是否存在 System.out.println(list.isEmpty());//判断是否为空 //获取位置 System.out.println(list.indexOf("苹果")); //subList使用 List subList=list.subList(1,3); System.out.println(subList.toString()); } } -
存放基本数据类型会自动装箱
-
删除int类型数据时，需转成Object类型或Integer类型
-
(Object) a new Integer(a)
List接口的实现类：
ArrayList()使用:
-
ArrayList()：数组结构实现，查询快，增删慢，运行效率快，线程不安全
-
ArrayList()使用:
package com.wly.Dome; public class Man { private String name; private int age; public Man(String name, int age){ this.name=name; this.age=age; } }package com.wly.Dome; import java.util.*; //collection保存表 public class Demo { public static void main(String[] args) { //创建集合ArrayList ArrayList arrayList=new ArrayList(); //添加元素 Man m1=new Man("张三",20); Man m2=new Man("李四",30); Man m3=new Man("王五",30); arrayList.add(m1); arrayList.add(m2); arrayList.add(m3); System.out.println("元素个数"+arrayList.size()); System.out.println(arrayList.toString()); //删除元素 // arrayList.remove(m1); // arrayList.remove(new Man("王五",30)); // System.out.println("元素个数"+arrayList.size()); //迭代器遍历元素 System.out.println("迭代器遍历元素"); Iterator it=arrayList.iterator(); while (it.hasNext()){ Man l=(Man) it.next(); System.out.println(l.toString()); // System.out.println(ali.next()); } //列表迭代器 System.out.println("列表迭代器遍历元素"); ListIterator lit=arrayList.listIterator(); while (lit.hasNext()){//向后，调整指针 System.out.println(lit.nextIndex()+":"+lit.next()); } while (lit.hasPrevious()){//向前 System.out.println(lit.previousIndex()+":"+lit.previous()); } //判断 // System.out.println(arrayList.contains(m1));//判断是否存在 System.out.println(arrayList.contains(new Man("王五",30)));//判断是否存在 System.out.println(arrayList.isEmpty());//判断是否为空 //查找 System.out.println(arrayList.indexOf(new Man("王五",30) ));//Man方法中重写了equals，可以通过new对象判断 } }
Vector()使用：
-
Vector()：数组结构实现，查询快，增删慢，运行效率慢，线程安全
-
Vector()使用：
package com.wly.Dome; import java.lang.invoke.VarHandle; import java.util.*; //collection保存表 public class Demo { public static void main(String[] args) { //创建元素 Vector vector=new Vector(); vector.add("西瓜"); vector.add("黄瓜"); vector.add("木瓜"); System.out.println(vector.toString()); //删除.... //遍历 Enumeration en=vector.elements();//枚举器遍历 while (en.hasMoreElements()){ String o=(String) en.nextElement(); System.out.println(o); } //判断..... //其他方法 System.out.println(vector.firstElement());//得到第一个元素， // 最后一个元素lastElement() //某个位置元素vector.elementAt(index) } }
LinkedList()使用：
-
LinkedList():双向链表(指向结构)结构实现，增删快，查询慢
-
LinkedList()使用
package com.wly.Dome; import java.util.Iterator; import java.util.LinkedList; import java.util.ListIterator; public class Demo { public static void main(String[] args) { LinkedList linkedList=new LinkedList(); //添加 Man m1=new Man("张三",12); Man m2=new Man("李四",13); Man m3=new Man("王五",16); linkedList.add(m1); linkedList.add(m2); linkedList.add(m3); System.out.println(linkedList.toString()); //删除 // linkedList.remove(new Man("王五",16)); // System.out.println(linkedList.toString()); //遍历。。。。 for (int i = 0; i <linkedList.size() ; i++) { System.out.println(linkedList.get(i)); } Iterator it=linkedList.listIterator(); while (it.hasNext()){ System.out.println(it.next()); } //列表迭代器 ListIterator lit=linkedList.listIterator(); while (lit.hasNext()) { System.out.println(lit.next()); } //判断 System.out.println(linkedList.contains(m2)); System.out.println(linkedList.isEmpty()); //获取位置 System.out.println(linkedList.indexOf(m2)); } } -
ArrayList与LinkedList：ArrayList数组，连续。LinkedList链表，不连续
泛型
-
泛型<T,…>T称为类型占位符，表示一种引用类型
-
本质是参数化类型，把类型作为参数传递
-
常见有泛型类，泛型接口，泛型方法
-
好处是提高代码的重用性，防止类型转换异常，提高代码的安全性。
泛型类
-
package com.wly.Dome; //泛型类 //类名<T> public class MyGeneric<T>{ //使用泛型T //创建变量 T t; //把泛型作为方法的参数 public void show(T t){ System.out.println(t); } //把泛型作为方法的返回值 public T getT(){ return t; } } -
package com.wly.Dome; public class MyGenericTest { public static void main(String[] args){ MyGeneric<String> mygeneric=new MyGeneric<String>(); mygeneric.t="hello"; mygeneric.show("大家好，加油"); String string=mygeneric.getT(); MyGeneric<Integer> mygeneric2=new MyGeneric<Integer>(); mygeneric2.t=20; mygeneric2.show(200); Integer integer=mygeneric2.getT(); } }
泛型接口
-
package com.wly.Dome; //不能创建泛型静态常量 public interface MyInterface<T> { String name="张三"; T server(T t);//泛型方法 } -
package com.wly.Dome; public class MyInterfaceImpl implements MyInterface<String>{ @Override public String server(String t) { System.out.println(t); return t; } } -
package com.wly.Dome; public class MyInterTest { public static void main(String[] args){ MyInterfaceImpl myInterface=new MyInterfaceImpl(); myInterface.server("泛型接口类"); } } -
package com.wly.Dome; public class MyInterfaceImpl<T> implements MyInterface<T>{ //跟随接口的泛型类，接口是什么类型，这个类就是什么类型 @Override public T server(T t) { System.out.println(t); return t; } } -
package com.wly.Dome; public class MyInterTest { public static void main(String[] args){ MyInterfaceImpl<Integer> myInterface=new MyInterfaceImpl<Integer>(); myInterface.server(100); } }
泛型方法
-
package com.wly.Dome; //语法<T>返回值类型 public class Demo { //泛型方法 public <T> void show(T t) {//无返回值 System.out.println("泛型方法"); } // public <T> T show(T t){//有返回值 // System.out.println("泛型方法"); // return t; // } } -
package com.wly.Dome; //abstract抽象类 public class DemoTest { public static void main(String[] args){ Demo demo=new Demo(); demo.show("nihao"); demo.show(12); demo.show(12.2); } }
泛型集合
- 参数化类型、类型安全集合、强制集合元素的类型必须一致
Set子接口
Set接口及使用
-
package com.wly.Dome; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Demo { public static void main(String[] args){ Set<String> set=new HashSet(); //添加数据 set.add("小米"); set.add("苹果"); set.add("华为"); System.out.println("数据个数"+set.size()); System.out.println(set.toString()); //删除 set.remove("小米"); System.out.println("数据个数"+set.size()); //遍历 //增强for遍历 for (String string:set) { System.out.println(string); } //使用迭代器遍历 Iterator it=set.iterator(); while (it.hasNext()) { System.out.println(it.next()); } //判断 System.out.println(set.contains("华为")); System.out.println(set.isEmpty()); } }
Set接口的实现类
HashSet使用
-
基于HashCode实现元素不重复
-
当存入元素的哈希码相同时，回调用equals进行确认，如果结果为true，则拒绝存入
-
package com.wly.Dome; import java.util.Objects; public class Man { private String name; private int age; public Man(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 hashCode() { int n1=this.name.hashCode(); int n2=this.age; return n1+n2; } public boolean equals(Object obj){ if(this==obj){ return true; }if (obj==null){ return false; }if (obj instanceof Man){//是否为Man类型 Man m=(Man) obj; //比较属性 if(this.name.equals(m.getName())&&this.age==m.getAge()){ return true; } } return false; } @Override public String toString() { return "Man{" + "name='" + name + '\'' + ", age=" + age + '}'; } } -
package com.wly.Dome; //存储结构：哈希表（数组+链表+红黑树） //根据hashcode计算保存位置，如果为空，直接保存 //如果不为空，执行equals方法，如果equals方法为true，则认为是重复, 否则形成链表 import java.util.HashSet; import java.util.Iterator; public class Demo { public static void main(String[] args){ HashSet<Man> man=new HashSet<>(); //添加 Man m1=new Man("张三",10); Man m2=new Man("李四",12); Man m3=new Man("王五",42); man.add(m1); man.add(m2); man.add(m3); man.add(new Man("王五",42));//可以添加，因为是不同对象，阻止添加需对其进行hashcode和equlas判断 System.out.println("数据个数"+man.size()); System.out.println(man.toString()); //删除 // man.remove(m1); // man.remove(new Man("王五",42)); //遍历 //for增强遍历 System.out.println("========"); for (Man man1:man) { System.out.println(man1.toString()); } //迭代器 System.out.println("========"); Iterator iterator=man.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } }
TreeSet使用
-
基于排列顺序实现元素不重复
-
实现了SortedSet接口，对集合元素自动排序
-
元素对象的类型必须实现Comparable接口，指定排序规则
-
通过CompareTo确定是否有重复元素
-
package com.wly.Dome; import java.util.Objects; public class Man implements Comparable<Man>{ private String name; private int age; public Man(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; } public boolean equals(Object obj){ if(this==obj){ return true; }if (obj==null){ return false; }if (obj instanceof Man){//是否为Man类型 Man m=(Man) obj; //比较属性 if(this.name.equals(m.getName())&&this.age==m.getAge()){ return true; } } return false; } @Override public String toString() { return "Man{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override //先按姓名，在按年龄 public int compareTo(Man o) { int n1=this.getName().compareTo(o.getName()); int n2=this.age-o.getAge(); return n1==0?n2:n1; } } -
package com.wly.Dome; //存储结构：红黑树 //存储过程：需先进行比较 //元素要实现Comparable接口，comparable方法返回值为0，认为是重复元素 import java.util.Iterator; import java.util.TreeSet; public class Demo { public static void main(String[] args){ TreeSet<Man> man=new TreeSet<>(); //添加 Man m1=new Man("张三",10); Man m2=new Man("李四",12); Man m3=new Man("王五",42); man.add(m1); man.add(m2); man.add(m3); System.out.println("数据个数"+man.size()); System.out.println(man.toString()); //删除 // man.remove(m1); // man.remove(new Man("王五",42)); //遍历 //for增强遍历 System.out.println("========"); for (Man man1:man) { System.out.println(man1.toString()); } //迭代器 System.out.println("========"); Iterator iterator=man.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } }
Comparator接口
-
重写内部类指定排序规则
-
package com.wly.Dome; import java.util.Comparator; import java.util.TreeSet; //TreeSet集合使用 //Comparator：实现定制器比较（比较器） //Comparable：可比较的 public class Demo { public static void main(String[] args){ //创建集合并指定比较规则 TreeSet<Man> man=new TreeSet<>(new Comparator<Man>() { @Override public int compare(Man o1, Man o2) { int n1=o1.getAge()-o2.getAge(); int n2=o1.getName().compareTo(o2.getName()); return n1==0?n2:n1; } }); } } -
//实现字符串排序 package com.wly.Dome; import java.util.Comparator; import java.util.TreeSet; public class TestEg { 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==n2?n2:n1; } }); treeSet.add("zhangsan"); treeSet.add("wang"); treeSet.add("cat"); treeSet.add("hello"); System.out.println(treeSet.toString()); } }
Map集合概述
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7bGDKLXW-1648795945440)(D:\笔记\JAVA集合框架\photo\IMG_1285(20220326-190504)].PNG)
Map父接口
-
方法：V put(K key,V value)//将对象存入集合中，关联键值。key重复则覆盖原值。
-
Object get(Object key)//根据键获取对应值
-
Set//返回所有的key
-
Collection values()//返回包含所有值的Collection。
-
Set<Map.Entry<K,V>>//键值匹配的Set集合。
-
Map接口使用
package com.wly.Dome; import java.util.HashMap; import java.util.Map; import java.util.Set; //Map接口使用 //键值对存储，键不能重复，值可以重复，无续 public class Demo { public static void main(String[] args){ Map<String,String> map=new HashMap<>(); //添加 map.put("cn","中国"); map.put("uk","英国"); map.put("usa","美国"); map.put("cn","China");//后一个添加会根据前一个键修改值 System.out.println("元素个数："+map.size()); System.out.println(map.toString()); //删除 // map.remove("cn"); // System.out.println(map.size()); //遍历 //使用keySet();Set集合 Set<String> keyset=map.keySet(); for (String key:keyset) { System.out.println(key+":"+map.get(key));//键值获取 } //使用entrySet(),将键值存储为Entry类型 Set<Map.Entry<String,String>> entries=map.entrySet(); for (Map.Entry<String,String> entry:entries){ System.out.println(entry.getKey()+":"+entry.getValue()); } //判断 System.out.println(map.containsKey("cn")); System.out.println(map.containsValue("中国")); } }
HashMap
-
初始容量16
-
线程不安全，运行效率快，允许null作为key或value
-
package com.wly.Dome; import java.util.Objects; public class Man{ private String name; private int age; public Man(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; } public Man() { super(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Man man = (Man) o; return age == man.age && Objects.equals(name, man.name); } @Override public int hashCode() { return Objects.hash(name, age); } @Override public String toString() { return "Man{" + "name='" + name + '\'' + ", age=" + age + '}'; } } -
package com.wly.Dome; import java.util.HashMap; import java.util.Map; //HashMap //存储结构：哈希表 //使用key的Hashcode和equals public class Demo { public static void main(String[] args){ //创建集合 HashMap<Man,String> man=new HashMap<Man,String>();//Man类作为键 //添加元素 Man m1=new Man("张三",36); Man m2=new Man("李四",36); Man m3=new Man("王五",36); man.put(m1,"上海");// man.put(m2,"北京"); man.put(m3,"西安"); man.put(m3,"南京"); man.put(new Man("王五",36),"南京");//相当于新建对象，不重复，可以添加 //要使其无法添加，需重写HashCode和equals方法 System.out.println(man.size()); System.out.println(man.toString()); //删除 // man.remove("m1"); System.out.println(man.toString()); //遍历 //使用KeySet for (Man key:man.keySet()) { System.out.println(key.toString()+":"+man.get(key)); } //使用entrySet for (Map.Entry<Man,String> entry:man.entrySet()) { System.out.println(entry.getKey()+"-----"+entry.getValue()); } //判断 System.out.println(man.containsKey(new Man("王五",36)));//重写了HashCode方法与equlas方法，所以能查到，返回为true } }
Hashtable和Properties
- Hashtable线程安全，运行效率慢；不允许null作为key或value的值
- Properties为Hashtable的子类，要求key与value都是String类型，通常用于配置文件读取
Properties：属性集合
-
特点：
- 存储属性名与属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
package com.wly.Dome; import java.awt.print.Pageable; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.PrintWriter; import java.util.Properties; import java.util.Set; public class TestDome { public static void main(String[] args)throws Exception{ //创建集合 Properties properties=new Properties(); //添加数据 properties.setProperty("username","张三"); properties.setProperty("age","29"); System.out.println(properties.toString()); //遍历 //---------keySet //-----------entrySet //----------stringPropertyNames() Set<String> pronames=properties.stringPropertyNames(); for (String pro:pronames ) { System.out.println(pro+"====="+properties.getProperty(pro)); } //和流有关的方法 //-----list方法 PrintWriter pw=new PrintWriter("d:\\print.txt"); properties.list(pw); pw.close(); //store方法---------保存 FileOutputStream fos=new FileOutputStream("d:\\store.properties"); properties.store(fos,"注释"); fos.close(); //load方法------------加载 Properties properties2=new Properties(); FileInputStream fis=new FileInputStream("d:\\store.properties"); properties2.load(fis); fis.close(); System.out.println(properties2.toString()); } }
TreeMap
-
实现了SortedMap的接口，可以对key进行自动排序
-
package com.wly.Dome; import java.util.Objects; public class Man implements Comparable<Man>{ private String name; private int age; public Man(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; } public Man() { super(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Man man = (Man) o; return age == man.age && Objects.equals(name, man.name); } @Override public String toString() { return "Man{" + "name='" + name + '\'' + ", age=" + age + '}'; } public int compareTo(Man o) {//制定树的排序规则 int n1=this.name.compareTo(o.getName()); int n2=this.age-o.getAge(); return n1==n2?n2:n1; } } -
package com.wly.Dome; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; //TreeMap //存储结构：红黑树 public class Demo { public static void main(String[] args){ //创建集合 TreeMap<Man,String> man=new TreeMap<Man,String>(); //添加元素 Man m1=new Man("张三",36); Man m2=new Man("李四",36); Man m3=new Man("王五",36); man.put(m1,"上海");// man.put(m2,"北京"); man.put(m3,"西安"); man.put(m3,"南京"); man.put(new Man("王五",36),"南京");//添加了比较规则，key值相同，不能添加，value被替换 //要使其无法添加，需重写HashCode和equals方法 System.out.println(man.size()); System.out.println(man.toString()); //删除 // man.remove("m1"); System.out.println(man.toString()); //遍历 //使用KeySet for (Man key:man.keySet()) { System.out.println(key.toString()+":"+man.get(key)); } //使用entrySet for (Map.Entry<Man,String> entry:man.entrySet()) { System.out.println(entry.getKey()+"-----"+entry.getValue()); } //判断 System.out.println(man.containsKey(new Man("王五",36)));//重写了HashCode方法与equlas方法，所以能查到，返回为true } } -
也可以定制比较，定义内部类compare()
Colletions工具类
-
package com.wly.Dome; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class Demo { public static void main(String[] args){ List<Integer> list=new ArrayList<>(); list.add(10); list.add(12); list.add(13); list.add(16); list.add(20); //sort排序 System.out.println("排序之前"+list.toString()); 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 j = 0; j < list.size(); j++) { dest.add(0); } Collections.copy(dest,list);//要求大小一样,将list拷贝到dest System.out.println(dest.toString()); //reverse反转 Collections.reverse(list); System.out.println(list.toString()); //shuffle打乱 Collections.shuffle(list); System.out.println(list.toString()); //list转数组 Integer[] arr=list.toArray(new Integer[0]); System.out.println(Arrays.toString(arr)); //数组转list String[] name={"张三","李四","王五"}; List<String> list2=Arrays.asList(name); //受限集合，不能添加和删除，因为集合长度固定 System.out.println(list2); //把基本类型修转为集合是，需要修改包装类 Integer[] nums={100,20,299,100}; List<Integer> list3=Arrays.asList(nums); System.out.println(list3); } }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 j = 0; j < list.size(); j++) { dest.add(0); } Collections.copy(dest,list);//要求大小一样,将list拷贝到dest System.out.println(dest.toString()); //reverse反转 Collections.reverse(list); System.out.println(list.toString()); //shuffle打乱 Collections.shuffle(list); System.out.println(list.toString()); //list转数组 Integer[] arr=list.toArray(new Integer[0]); System.out.println(Arrays.toString(arr)); //数组转list String[] name={"张三","李四","王五"}; List<String> list2=Arrays.asList(name); //受限集合，不能添加和删除，因为集合长度固定 System.out.println(list2); //把基本类型修转为集合是，需要修改包装类 Integer[] nums={100,20,299,100}; List<Integer> list3=Arrays.asList(nums); System.out.println(list3); }}
2986
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
