这篇博客详细介绍了Java集合框架，包括Collection接口的子接口List和Set，以及Map接口的实现类。重点讨论了List接口的实现如ArrayList、LinkedList、Vector，Set接口的实现如HashSet、LinkedHashSet、TreeSet，以及Map接口的HashMap、LinkedHashMap、TreeMap等。此外，还涵盖了集合的基本操作、遍历方法、同步控制以及foreach循环的使用。
索引
集合
使用Array存储对象方面具有一些弊端，而java集合就像一种容器，可以动态德把多个对象的引入放入容器中
1 集合框架的概述
- 1.集合、数组都是对多个数据进行存储操作的结构，简称java容器
说明：此时的存储，主要指内存层面的存储，不涉及到持久化的存储（.txt,.jpg)
-
2.1数组在存储多个数据方面的特点
- 一旦初始化以后，其长度就确定了。
- 数据一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如String[]，arr,int[]
-
2.2 数组 在存储多个数据方面的缺点
-
一旦初始化以后，其长度就不可修改
-
数组中提供的方法非常有限，对于添加。删除、插入数据等操作，非常不便，同事效率不高。
-
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
-
数组存储数据的特点：有序、可重复。对于无需，不可重复的需求不能满足
-
2.集合框架
2.1 Collection接口（单列集合）
单列集合，用来存储一个一个的对象
2.1-1 List接口：存储有序的、可重复的数据 —>“动态”数组
- ArrayList
- LinkedList
- Vector
2.1-2 Set接口：存储无序的、不可重复的数据 —> 高中讲的”集合“
- HashSet
- LinkedHashSet
- TreeSet
2.2 Map接口
双列集合，用来存储一对（key、value）一对的数据 -->高中函数
- HashMap
- LinkedHashMap
- TreeMap
- HashTable
- Properties
2.2 Collection接口中的方法的使用
2.2-1 常用方法
-
add()
将元素e添加到集合coll中
Collection coll = new ArrayList();
//add(object e):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
- size():获取集合的长度（元素的个数）
- addAll():把集合coll中的元素添加到coll2中
Collection coll = new ArrayList();
//add(object e):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
System.out.println(coll.size());
//addAll(Collection coll): 将coll集合中的元素添加到当前集合中
Collection coll2 = new ArrayList();
coll.add(456);
coll.add("CC");
coll.addAll(coll);
System.out.println(coll.size());
//输出结果
4 //coll的长度
12 //coll2的长度
- clear()
清除集合中的元素
coll.clear();
System.out.println(coll.size());
//输出结果
0
-
isEmpty():判断集合是否为空
coll.clear(); System.out.println(coll.isEmpty()); //输出结果 true
2.2-2 contains()
判断当前集合是否包含obj。在判断时会调用obj对象所在类的equals()
public void test() {
Collection coll = new ArrayList();
coll.add(123);
coll.add("BB");
coll.add("CC");
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person(20 ,"Jerry"));//这里new 了一个Person对象
boolean contains = coll.contains(123);
System.out.println(contains);
System.out.println(coll.contains(new String("Tom")));
//没有重写toString,调用的是object，比的就是==地址值，所以和添加的不一样
System.out.println(coll.contains(new Person(20,"Jerry")));
//这里在输出coll.contains内也new了Person。在没有重写equals方法的时候，输出结果将是false。 因为该语句判断的是coll对象内部是否包含20岁的Jerry.但是没有重写equals，所以比较的地址值不一样
}
}
//下面是Person类中重写equals类（用快速生成就行）
class Person{
//属性和方法等不写
@Override
public boolean equals(Object o) {
System.out.println("person equals()");//这个语句是为了看是否调用了equals方法来做的测试语句
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);
}//现在重写了equlas类
//下面还有个HashCode在这里没有用，省略
}
//输出结果（test类中的输出）
true
true
person equals()
person equals()
person equals()
person equals()
person equals()
person equals()
true
//出现了多个Person类中的测试语句，说明在contains方法中调用了重写的equals类，从而输出true（输出时的20岁Jerry 和add的20岁的Jeryy 为内容相同）
2.2-3 containsAll(Collection coll) 判断形参coll中的所有元素是否都存在于当前集合中
Collection coll2 = Arrays.asList(123,456);
System.out.println(coll.containsAll(coll2));
//输出结果
false
//因为coll中没有456
2.2-4 remove()
public void test() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person(20 ,"Jerry"));
coll.remove(123);
System.out.println(coll);
coll.remove(new String("Tom"));
System.out.println(coll);
coll.remove(new Person(20,"Jerry"));
System.out.println(coll);
}
}
//输出结果
[456, Tom, false, Person{age=20, name='Jerry'}]
[456, false, Person{age=20, name='Jerry'}]
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
[456, false]
//必须要重写Person类的equals方法才能删除Person类的元素
//Person类中
public boolean equals(Object o) {
System.out.println("出现这一串字说明调用了重写的equals方法");
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);
}
}
2.2-5 removeAll（Collection coll）：差集：从当前集合中移除coll的所有的元素
public void test() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person(20, "Jerry"));
coll.removeAll(coll);
System.out.println(coll);
}
}
//输出结果
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
出现这一串字说明调用了重写的equals方法
[]
//集合coll中所有元素都被删除了
2.2-6 hashCode()
System.out.println(coll.hashCode());
返回coll的hash值 （一个随机值，用来记录位置）
2.2-7 集合------>数组
Object[] arr = coll.toArray();
for(int i = 0 ;i<arr.length;i++){
System.out.println(arr[i]);
}
//输出结果
123
456
Tom
false
Person{age=20, name='Jerry'}
-
数组转化为集合
List<Collection> collections = Arrays.asList(coll); System.out.println(collections); //输出结果 [[123, 456, Tom, false, Person{age=20, name='Jerry'}]] List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"}); System.out.println(list); //输出结果 [AA, BB, CC] //写Arrays.aslist(); 然后用alt+回车来自动生成list<Collection>List<Integer> arr1 = Arrays.asList(new Integer(123), new Integer(456)); System.out.println(arr1); //输出结果 [123, 456] //如果不创建Integer而是创建int，输出的arr1就是地址值。 List<int[]> arr2 = Arrays.asList(new int[]{123, 456}); System.out.println(arr2); //输出结果 [[I@48533e64]
2.2-8 iterator() （集合的遍历）
返回Iterator接口（迭代器Iterator接口）的实例，用于遍历集合元素，放在IteratorTest.java
先创建iterator的对象，然后调用next方法
iterator接口遍历集合 方式一
方式一
public void test(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Iterator iterator= coll.iterator();
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
//报异常只有5个元素 //NosuchElementException
System.out.println(iterator.next());
}
//每设置一个iterator.next()就会遍历一个元素。有5个的话调用5个就会输出5个，调用4个就会输出4个。如果调用6个就会报错
//输出结果
123
456
Tom
false
Person{name='Jerry', age=20} //重写了toString
方式二（不推荐）
public void test(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Iterator iterator=coll.iterator();
for(int i = 0;i<coll.size();i++){
System.out.println(iterator.next());
}
}
//输出结果
123
456
Tom
false
Person{name='Jerry', age=20}
方式三 （推荐）
hasNext():判断是否集合中还有元素。
说明：hasNext()判断是否有下一个元素，如果有就执行while语句，执行interator.next(),一直到没有元素需要输出
public void test(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Iterator iterator=coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}`
说明
- 集合对象每次调用iterator()方法都会得到一个全新的迭代器对象，默认游标都走集合的第一个元素之前
2.2-9 remove() 移除集合中的元素
public void test(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Iterator iterator=coll.iterator();
//判断是否有下一个元素，如果有下一个元素，这个元素如果是Tom的话，就删除它
while(iterator.hasNext()){
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
}
}
//执行完之后，next就已经走到了最后，下面需要重新新建一个iterater从头开始遍历
//重新获取coll
iterator=coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
注意
- iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
- 如果还未调用next()或在上一次调用next方法之后已经到调用了remove方法， 再调用remove都会报illegalStateException
2.3 foreach循环（增强for循环）遍历集合和数组元素
内部仍然调用了迭代器
public void test() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry", 20));
//for(集合元素的类型 局部变量 :集合对象)
for(Object obj :coll) {
System.out.println(obj);
}
}
用foreach遍历数组
public void test2(){
int [] arr = new int []{1,2,3,4,5,6};
//for(数组元素的类型 局部变量:数组对象)
for(int i :arr){
System.out.println(i);
}
}
2.4 List接口三个实现类的对比
- ArrayList：作为List接口的主要实现类，线程安全的，效率高；底层使用Object[]存储
- LinkedLIst:对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
- VectorList:作为List接口的古老实现类，线程安全的，效率低；底层使用Object[] elementData存储
面试题
- ArrayList、LinkedList、Vector三者的异同
- 三个类都实现了List接口，存储数据的特点相同：存储有序的，可重复的数据
2.5 List总结
-
增：add(Object obj)
-
删：remove(int index)/remove(Object obj)
-
改：set(int index,Object ele)
-
查：get(int index)
-
插：add(int index,Object ele)
-
长度：size()
-
遍历
- ①Iterator迭代器方式
- ②增强for循环（for each）
- ③普通的循环
3 .Set接口框架
3.1 Collection接口
- 单例集合，用来存储一个一个的对象
3.2 Set接口
Set接口中没有额外定义的方法，使用的都是Collection中声明的方法
-
存储无序的、不可重复的数据—>高中讲的集合
- 无序性：无序性不等于随机性（每次都是一样的顺序，但是是无序的）。存储的数组在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定。
public void test() { Set set = new HashSet(); set.add(456); set.add(123); set.add("AA"); set.add(new Person("Tom",12)); set.add("CC"); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } //输出结果 AA CC Person{name='Tom', age=12} 456 123 -
不可重复性（在Person类中重写equals方法来检测）
添加相同的元素，只会输出一次保证元素按照equals()判断时，不能返回true：即相同的元素只能添加一个。
//class Person:在Person类中重写了equals方法，然后生成了hashcode方法。
在上面的equals方法里面添加一个输出语句，Person equals()...用来判断调用的时候是否执行了改方法
@Override
public boolean equals(Object o) {
System.out.println("Person equals().....");
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);
}
//在test中测试
@Test
public void test() {
Set set = new HashSet();
set.add(456);
set.add(123);
set.add("AA");
set.add(new Person("Tom",12));
set.add(new Person("Tom",12));
set.add("CC");
set.add("CC");
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//输出结果
Person equals()..... //证明调用了equals方法。前提是要有hashcode方法
AA
CC
456
123
Person{name='Tom', age=12}
3.2-1 Set接口的实现类
- HashSet:作为Set接口的主要实现类；线程不安全的；可以存储null值。
- LinkedHashSet： 作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。
- TreeSet：可以按照添加对象的指定属性，进行排序。
说明
- 向set中添加的数据，其所在类一定要重写hashcode()和equals()
@Override
public boolean equals(Object o) {
System.out.println("Person equals().....");
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);
}
//重写hashcode
@Override
public int hashCode() {
return Objects.hash(name, age);
}
- 重写的hashcode()和equals方法尽可能的保持一致性，拥有相同的散列码。
- *散列码：一种标识码（在底层中有所体现）。
3.2-2 LinkedHashSet的使用
-
作为HashSet的子类，使用方法和HashSet相同。采用了双向链表用来维护添加的前后两个数据。在频繁进行遍历操作时，效率高于HashSet。
-
add, clear, clone, contains, isEmpty, iterator, remove, size
3.2-3 TreeSet自然排序
接口方法和Hashset相同
举例一
报错案例，同时添加了int和String型的元素
@Test
public void test() {
TreeSet set = new TreeSet();
set.add(123);
set.add("AA");
}
//报错输出
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
举例二
对对象全部都是int型的和全部都是String型的。此处只举例int型
@Test
public void test() {
TreeSet set = new TreeSet();
set.add(123);
set.add(456);
set.add(789);
set.add(-123);
Iterator iterator =set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//输出结果会按照从大到小的顺序来输出（String型也会按照）
-123
123
456
789
说明
- 当添加的字符串为数字时，会根据 字符串首位的unicode码的大小进行排序。
举例三
重写Comparable接口里面的方法。实现针对于对象的属性进行定制排序
//class Person: Person继承了Comparable
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person person = (Person) o;
return this.name.compareTo(person.name);
}
throw new RuntimeException("该对象不属于Person");
}
//Test类
@Test
public void test() {
TreeSet set = new TreeSet();
set.add(new Person("Mike",20));
set.add(new Person("Jack",20));
set.add(new Person("Tom",20));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//输出结果
Person{name='Jack', age=20}
Person{name='Mike', age=20}
Person{name='Tom', age=20}
- //Person类中，CompareTo方法对name属性进行了重写，按照name属性的首字母从小到大进行了排序。
- 如果要进行从大到小的方式进行排序，需要利用CompareTo方法对名字排序写法的返回值进行修改。（相反数）
举例四
对象的排序属性相同，需要根据第二个属性进行排序
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person person = (Person) o;
int compare = this.name.compareTo(person.name);
//接收值，为了判断是否两个对象比较的属性相同，如果相同则输出0。
if(compare==0){
return Integer.compare(this.age,person.age);//接收到的值为0，表示两个对象的name属性相同，则返回的是对age属性排序后的结果。
}else{
return compare;
}
}
throw new RuntimeException("该对象不属于Person");
}
//在test测试类中输出的结果
Person{name='Jack', age=18}
Person{name='Jack', age=20}
//两个对象的name属性相同， 则对age进行比较排序。
Person{name='Mike', age=20}
Person{name='Tom', age=20}
- 自然排序和定制排序中，如果compareTo比较两个对象的属性（name）相同，则会输出 0；
- Integer.compare(x,y)；对int型的数据进行比较。
说明
- 不能添加不同类的对象。
3.3 Map接口
双列数据，存储key-value对的数据
Map的添加方法是put()而不是add()
-
HashMap:作为Map的主要实现类：线程不安全的，效率高；存储null的key和value
- LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。在原有的HashMap底层结构基础上，添加；了一对指针，指向前后两个元素。 对于频繁的遍历操作，此类执行效率高于HashMap。
-
TreeMap:按照添加的key—value进行排序，实现排序遍历。考虑key的自然排序或者定制排序。（底层使用红黑树）
-
HashTable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
- Properties:常用来处理配置文件。key和value都是String类型。
HashMap的底层：数组+链表（jdk7以前），数组+链表+红黑树（jdk8）
Map结构的理解
- Map中的key是无序的，不可重复的，使用set存储所有的key；–>Key所在的类要重写equals()和HashCode()
- Map中的value是无序的，可重复的，使用Collection来存储所有的value；
- 一个键值对：key-value构成了一个Entry对象；
- Map中的entry是无序的，不可重复的，使用set存储所有的entry。
jdk8底层实现
- new HashMap():底层没有创建一个长度为16的数组
- jdk8底层的数组是：node[]，而不是Entry[]
- 首次调用put()方法时，底层创建长度为16的数组。
- jdk7底层结构只有：数组+链表。jdk8底层结构有数组+链表+红黑树。
3.3-1 Map接口定义的方法
- 添加
- 修改
@Test
public void test(){
Map map = new HashMap();
map.put("AA",123);
map.put("BB",456);
//修改
map.put("AA",789);
System.out.println(map);
}
//输出结果
{AA=789, BB=456}
//789的key和123的key相同，体现的是修改操作。后一个key覆盖前一个key对应的value
-
删除
remove(Object key)@Test public void test(){ Map map = new HashMap(); map.put("AA",123); map.put("BB",456); map.put("CC",789); map.remove("AA"); map.remove("BB"); System.out.println(map); } //输出结果 {CC=789} -
清除
@Test public void test(){ Map map = new HashMap(); map.put("AA",123); map.put("BB",456); map.put("CC",789); map.clear(); System.out.println(map); } //输出结果 {} -
获取
@Test public void test(){ Map map = new HashMap(); map.put("AA",123); map.put("BB",456); map.put("CC",789); System.out.println(map.get("BB")); } //输出结果 456 -
长度
Map.size()
-
是否包含指定的key
boolean containsKey(Object key) -
map是否为空
boolean isEmpty()
3.3-2 元视图的操作方法
-
遍历操作
Map不能使用iterator迭代器，需要遍历所有的key集。keySet()@Test public void test(){ Map map = new HashMap(); map.put("AA",123); map.put("BB",456); map.put("CC",789); Set set = map.keySet(); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } }遍历所有的value集@Test public void test(){ Map map = new HashMap(); map.put("AA",123); map.put("BB",456); map.put("CC",789); Collection values = map.values(); for(Object o:values){ System.out.println(o); } } //输出结果 123 456 789遍历所有的key-value
3.3-3 TreeMap
自然排序
@Test
public void test() {
TreeMap map =new TreeMap();
Person p1 = new Person("Tom",12);
Person p2 = new Person("Jack",15);
Person p3 = new Person("Mike",9);
map.put(p1,98);
map.put(p2,94);
map.put(p3,95);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
Map.Entry entry =(Map.Entry)obj;
System.out.println(entry.getKey()+"----->"+entry.getValue());
}
}
//输出结果
Person{name='Jack', age=15}----->94
Person{name='Mike', age=9}----->95
Person{name='Tom', age=12}----->98
//输出的是key-value
定制排序
在TreeMap map = newTreeMap()中新建一个comparator对象，然后重写比较方法。
@Test
public void test() {
TreeMap map =new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person u1 = (Person)o1;
Person u2 = (Person)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}
return 0;
}
});
Person p1 = new Person("Tom",12);
Person p2 = new Person("Jack",15);
Person p3 = new Person("Mike",9);
map.put(p1,98);
map.put(p2,94);
map.put(p3,95);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
Map.Entry entry =(Map.Entry)obj;
System.out.println(entry.getKey()+"----->"+entry.getValue());
}
}
//输出结果
Person{name='Mike', age=9}----->95
Person{name='Tom', age=12}----->98
Person{name='Jack', age=15}----->94
3.3-4 properties处理配置文件
- 在工程处新建一个file +后缀名 或者直接新建Resource Bundle（自动添加properties后缀名）。在里面填写配置文件
4.Collctions工具类
Collections是一个操作Set、List、Map的工具类（Collections是一个操作Collection、Map的工具类）
- reverse(List):反转List中元素的顺序
@Test
public void test() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(-97);
list.add(0);
System.out.println(list);
//reverse排序
Collections.reverse(list);
System.out.println(list);
}
//输出结果
[123, 456, 789, -97, 0]
[0, -97, 789, 456, 123]
- shuffle(List):对List集合元素进行随机排序
@Test
public void test() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(-97);
list.add(0);
System.out.println(list);
//shuffle排序
Collections.shuffle(list);
System.out.println(list);
}
//输出结果
[123, 456, 789, -97, 0]
[789, 0, 456, 123, -97]
- sort(List):根据元素的自然顺序对指定List集合元素进行升序排序
sort(List Comparator)根据指定的Comparator产生的顺序对List集合元素进行排序
@Test
public void test() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(-97);
list.add(0);
System.out.println(list);
//sort排序
Collections.sort(list);
System.out.println(list);
}
//输出结果
[123, 456, 789, -97, 0]
[-97, 0, 123, 456, 789]
- swap(List int,int):将指定List集合中的i处元素和j处元素进行交换
@Test
public void test() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(-97);
list.add(0);
System.out.println(list);
//sort排序
Collections.swap(list,1,2);
System.out.println(list);
}
//输出结果
[123, 456, 789, -97, 0]
[123, 789, 456, -97, 0]
-
Object max(Collection):根据元素的自然排序，返回给定集合中的最大元素
Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大值。 -
Object min(Collection)/Object min(Collection,Comparator)
-
int frequency(Collection,Object):返回指定集合中指定元素出现次数
@Test
public void test() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(-97);
list.add(0);
list.add(0);
System.out.println(list);
//返回出现的次数
int frequency=Collections.frequency(list,0);
System.out.println(frequency);
}
//输出结果
[123, 456, 789, -97, 0, 0]
2
-
copy
将src（list）中的内容赋值到dest中造的dest的数组长度必须和list相同才能完整的copy
@Test public void test() { List list = new ArrayList(); list.add(123); list.add(456); list.add(789); list.add(-97); list.add(0); list.add(0); System.out.println(list); List dest = Arrays.asList(new Object[list.size()]);//定义dest的长度为list的长度（保证容得下size） Collections.copy(dest,list); System.out.println(dest); } //输出结果 [123, 456, 789, -97, 0, 0] [123, 456, 789, -97, 0, 0]
4.1 常用方法：同步控制
提供了sychronizedXxx()方法，可以使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合的线程安全问题。
扫一扫
603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
