Java基础知识 18
Collection集合
数组，不仅能存储基本数据类型，也能存储引用数据类型。
数组作为容器，可存储元素，但是数组作为容器，并不是很方便，如果我要对容器中的元素进行增删，就不方便。因为数组一旦定义，长度就固定了，如果你中途增删元素，就会改变数组的长度，就会报错。因此，Java中为了我们更加方便的对容器中的元素进行更加方便地操作，给我们提供了另外一种容器，叫集合。
集合与数组的区别：
相同点：都可以作为容器来存储元素。
数组的长度是固定的，一旦定义长度就固定了。
集合的长度是可变的。
不同点：数组不仅能存储基本数据类型，也能存储引用数据类型。但集合只能存储引用数据类型。
数组作为容器，容器中只能存储同一种数据类型。
集合作为容器，可以存储多种引用数据类型。
Collection中的方法：
（1）采用多态：Collection collection = new ArrayList();
add添加元素：集合中存储的是引用数据类型，collection.add(“abc”).
collection.add(100);//自动装箱
collection.add(new Integer(200));
collection.add(Integer.valueOf(300));
addAll:A集合.addAll(B集合)，把B集合中的元素全部添加到A集合中。
import java.util.ArrayList;
import java.util.Collection;
public class Mytest2 {
public static void main(String[] args) {
Collection collection =new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
Collection collection1=new ArrayList();
collection1.add(100);
collection1.add(200);
collection1.add(400);
//addAll把集合2中的元素添加到集合1中
//A集合addAll(B集合); 把B集合中的元素，放到A集合里面去
boolean b = collection.addAll(collection1);
System.out.println(b);
System.out.println(collection);
System.out.println(collection1);
}
}
----------------------------------------
import java.util.ArrayList;
import java.util.Collection;
public class Mytest {
public static void main(String[] args) {
//接口不能new，只能是new它的实现方法。
//多态形式
Collection collection=new ArrayList();
//在集合中添加元素：集合中存储的是引用数据类型
collection.add("abc");
//100不是引用类型，这里用到了自动装箱
collection.add(100);
collection.add(new Integer(200));
collection.add(Integer.valueOf(300));
System.out.println(collection);
//返回值表示元素是否添加成功
boolean b = collection.add(Double.valueOf(3.14));
System.out.println(b);
System.out.println(collection);
}
}
（2）remove:删除集合中某个元素。
clear:清空集合中元素。
emoveAll:A集合.removeAll(B集合)，在A集合中删除AB集合的交集元素。
import java.util.ArrayList;
import java.util.Collection;
public class Mytest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
collection.add(400);
collection.add(500);
//remove:删除集合中的某个元素
boolean b = collection.remove(300);
System.out.println(b);
System.out.println(collection);
//clear:清空集合中的元素
collection.clear();
System.out.println(collection);
System.out.println("------------------------");
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(200);
collection2.add(300);
collection2.add(400);
collection2.add(500);
collection2.add(600);
Collection collection3 = new ArrayList();
collection3.add(100);
collection3.add(200);
collection3.add(300);
collection3.add(400);
collection3.add(500);
//A集合.removeAll(B集合)：在A集合中删去A集合和B集合的交集元素。
//如果AB集合有交集元素，返回true，没有交集元素，返回false
boolean b1 = collection2.removeAll(collection3);
System.out.println(b1);
System.out.println(collection2);
System.out.println(collection3);
}
}
（3）contains:判断这个集合中是否包含这个元素。
containsAll:A集合.containsAll(B集合)，B集合中的元素在A集合中都能找到,就返回true，否则返回false。
import java.util.ArrayList;
import java.util.Collection;
public class Mytest2 {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("ddd");
collection.add("eee");
//contains:判断这个集合中是否包含此元素
boolean b = collection.contains("ddd");
System.out.println(b);
System.out.println(collection);
System.out.println("-------------------");
Collection collection2 = new ArrayList();
collection2.add("aaa");
collection2.add("bbb");
collection2.add("ccc");
collection2.add("ddd");
collection2.add("eee");
collection2.add("fff");
Collection collection3 = new ArrayList();
collection3.add("aaa");
collection3.add("bbb");
collection3.add("ccc");
collection3.add("ddd");
collection3.add("eee");
//collection3.add("hhh");
//A集合.containsAll(B集合)：B集合中的元素在A集合中都能找到，就返回true，否则返回false。
boolean b1 = collection2.containsAll(collection3);
System.out.println(b1);
System.out.println(collection2);
System.out.println(collection3);
}
}
（4）遍历：迭代器 Iterator iterator()
返回在此collection的元素上进行迭代的迭代器。
Iterator iterator = collection.iterator();
System.out.println(iterator);
//java.util.ArrayList$Itr 迭代器是ArrayList的内部类
通过迭代器来迭代集合中的元素
接口Iterator中的方法：
boolean hasNext();如果仍有元素可以迭代，返回true。
E next();返回迭代的下一个元素。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Mytest {
public static void main(String[] args) {
//遍历集合中的元素
Collection collection =new ArrayList();
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("ddd");
collection.add("eee");
/*
* 迭代器：Iterator<E> iterator()
* 返回在此collection的元素上进行迭代的迭代器
*/
Iterator iterator = collection.iterator();
System.out.println(iterator);
//java.util.ArrayList$Itr@1540e19d,迭代器是ArrayList的内部类
//通过迭代器来迭代集合中的元素
/*
*接口Iterator中的方法：
* (1)boolean hasnext();如果仍有元素可以迭代，返回true
* (2)E next();返回迭代器的下一个元素
*/
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
}
}
------------------------------------------
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Mytest {
public static void main(String[] args) {
//使用迭代器，来迭代集合
Collection list = new ArrayList();
//存储学生对象
list.add(new Student("小明",12));
list.add(new Student("小红",13));
list.add(new Student("小黄",14));
list.add(new Student("小蓝",15));
list.add(new Student("小杨",16));
Iterator iterator = list.iterator();
System.out.println(iterator);
while (iterator.hasNext()){
Object obj = iterator.next();
//向下转型
Student student= (Student) obj;
System.out.println(student.getName()+":"+student.getAge());
}
System.out.println("----------------");
Collection list2=new ArrayList();
list2.add(100);
list2.add(200);
list2.add(300);
list2.add(400);
list2.add(500);
Iterator iterator1 = list2.iterator();
System.out.println(iterator1);
while (iterator1.hasNext()){
Object obj = iterator1.next();
//向下转型
Integer num= (Integer) obj;
System.out.println(num);
}
System.out.println("-----------------");
//获取集合的长度
int size = list.size();
System.out.println(size);
int size1 = list2.size();
System.out.println(size1);
//获取字符串的长度
int l = "abcdef".length();
System.out.println(l);
//获取数组的长度
int length = new int[3].length;
System.out.println(length);
}
}
（5）retainAll:A集合.retainAll(B集合)，1）如果A集合是AB集合的交集，那么返回false，A集合中的元素没有发生变化。2）如果A集合中的元素除了AB集合的交集元素外，还有其他的元素，那么返回true，A集合中的元素发生变化，剩交集元素。3）如果A集合和B集合没有交集元素，那么A集合会被清空。
import java.util.ArrayList;
import java.util.Collection;
public class Mytest2 {
public static void main(String[] args) {
Collection collection= new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
collection.add(600);
Collection collection2= new ArrayList();
collection2.add(100);
collection2.add(200);
collection2.add(300);
collection2.add(400);
collection2.add(500);
boolean b = collection.retainAll(collection2);
System.out.println(b);
System.out.println(collection);
System.out.println(collection2);
}
}
（6）toArray:返回包含此数组的所有元素的数组。
把集合转换成数组：
Object[] objects=Collection.toArray();
System.out.println(Array.toString(objects));
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class Mytest {
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
collection.add(400);
collection.add(500);
collection.add(600);
//把集合转换成数组
Integer[] arr = new Integer[collection.size()];
Iterator iterator = collection.iterator();
int i=0;
while (iterator.hasNext()) {
Object obj = iterator.next();
Integer num= (Integer) obj;
arr[i]=num;
i++;
}
System.out.println(Arrays.toString(arr));
System.out.println("------------------------");
//Object[] toArray()
//返回包含此 collection 中所有元素的数组。
Object[] objects = collection.toArray();
System.out.println(Arrays.toString(objects));
}
}
List集合
List概述及特点：元素有序，并且每一个元素都存在一个索引，元素可以重复。
List集合特有的方法：
（1）add(int index,E element):在列表的指定位置上插入指定元素（可选操作）。
get(int index):返回列表中指定位置的元素。
import java.util.ArrayList;
import java.util.List;
public class Mytest {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
//在指定位置上插入指定元素
list.add(0,300);
System.out.println(list);
//通过索引来获取元素
Object o = list.get(1);
System.out.println(o);
System.out.println("-------------");
//通过for循环来遍历list数组
for (int i = 0; i < list.size(); i++) {
}
System.out.println(list);
}
}
（2）int indexOf(object o):返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
int lastIndexOf(object o):返回此列表中最后出现的指定元素的索引，如果此列表中不包含此元素，则返回-1。
import java.util.ArrayList;
public class Mytest3 {
public static void main(String[] args) {
//int indexOf(object o),
//返回此列表中第一次出现此元素的索引，如果列表中不包含此元素，则返回-1
ArrayList list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(300);
list.add(400);
list.add(500);
int i = list.indexOf(300);
System.out.println(i);
System.out.println("----------------------");
//int lastIndexOf(object o),
//返回此列表中最后出现的指定元素的索引，如果此列表不包含该元素，则返回-1
int j = list.lastIndexOf(400);
System.out.println(j);
}
}
（3）E remove(int index):根据索引移除列表中指定位置的元素（可选操作）。
E set(int index,E element):用指定元素替换列表中指定位置上的元素（可选操作）。
import java.util.ArrayList;
public class Mytest4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("fff");
//E remove(),根据元素删除，返回的是是否删除
boolean b = list.remove("ccc");
System.out.println(b);
System.out.println(list);
//E remove(int index),根据索引删除列表中指定位置的元素
Object obj = list.remove(2);
System.out.println(obj);
System.out.println(list);
System.out.println("--------------------");
ArrayList list2 = new ArrayList();
list2.add(100);
list2.add(200);
list2.add(300);
list2.add(300);
list2.add(400);
list2.add(500);
//E remove(),根据元素删除，返回的是是否删除
//因为这里的300无法区分是元素还是索引，所以我们把他包装成Integer类型。
boolean bb = list2.remove(Integer.valueOf(300));
System.out.println(bb);
System.out.println(list2);
//E remove(int index),根据索引删除列表中指定位置的元素
Object obj1 = list2.remove(0);
System.out.println(obj1);
System.out.println(list2);
}
}
---------------------------------------------
import java.util.ArrayList;
public class Mytest {
public static void main(String[] args) {
//E set(int index,E element),用指定元素替换列表中指定位置的元素。
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("fff");
//根据索引来替换集合中的元素，返回的是替换之前的旧元素
Object obj = list.set(3, "hhh");
System.out.println(obj);
System.out.println(list);
Object obj2 = list.set(list.size() - 1, "www");
System.out.println(obj2);
System.out.println(list);
}
}
（4）List subList(int fromIndex,int toIndex):返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图。
import java.util.ArrayList;
import java.util.List;
public class Mytest2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("fff");
//List<E> subList(int fromIndex,int toIndex),
//根据起始索引和终止索引截取一段元素到一个新的集合中。(取头不取尾)
List a = list.subList(0, 2);
System.out.println(a);
System.out.println(list);
}
}
（5）List IteratorlistIterator():返回此列表元素的列表迭代器（按适当顺序）。
正向迭代：ListIterator listIterator = list.listIterator();
while(list.hasNext()){
Object obj=listIterator.next();
System.out.println(obj);
}
反向迭代：ListIterator中特有的方法，可以进行反向迭代。
boolean hasPrevious();
如果以逆向遍历列表，列表中有多个元素，则返回true。
E Previous();返回列表中的前一个元素。
先进行正向迭代，才能进行反向迭代，而且要使用同一个迭代器。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Mytest2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("fff");
//正向迭代
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Object obj = listIterator.next();
System.out.println(obj);
}
System.out.println("-----------------------------");
//反向迭代
/*ListIterator 中的特有的方法 可以进行反向迭代
boolean hasPrevious ()
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E previous ()
返回列表中的前一个元素。
先进行正向迭代，才能进行反向迭代 你要是使用同一个迭代器对象*/
while (listIterator.hasPrevious()) {
Object obj = listIterator.previous();
System.out.println(obj);
}
}
}
List集合的三种遍历方式
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Mytest2 {
public static void main(String[] args) {
//List概述及特点:元素有序, 并且每一个元素都存在一个索引.元素可以重复.
ArrayList list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(400);
list.add(500);
list.add(600);
list.add(600);
list.add(600);
list.add(600);
//list的遍历方式有三种:
//遍历方式1：
Iterator iterator = list.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("-------------------------");
//遍历方式2：利用list特有的get()和size()方法来配合for循环进行遍历
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
//向下转型
Integer integer= (Integer) o;
System.out.println(integer);
}
System.out.println("-------------------------");
//遍历方式3：利用list特有的迭代器listIterator来实现
//listInteger继承自Iterator
ListIterator listIterator = list.listIterator();
System.out.println(listIterator);
while (listIterator.hasNext()) {
Object obj = listIterator.next();
System.out.println(obj);
}
}
}
List集合使用迭代器时的并发修改异常
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Mytest3 {
public static void main(String[] args) {
/*A:
案例演示
需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，
如果有，我就添加一个 "javaee" 元素，请写代码实现。*/
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("world");
list.add("ccc");
list.add("ddd");
//方式1：
if(list.contains("world")){
list.add("javaee");
}
System.out.println(list);
System.out.println("----------------------");
//方式2：使用迭代器自己的方法来进行判断添加
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Object obj = listIterator.next();
if(obj.equals("world")){
//要使用迭代器自己的方法来进行增删元素。
listIterator.add("javaee");
//list.add("javaee");//ConcurrentModificationException 并发修改异常
//list.remove("ccc");//ConcurrentModificationException 并发修改异常
//listIterator.remove();
}
}
System.out.println(list);
//并发修改异常的原因：往集合中添加完了元素，然后通过集合获取出迭代器，那么迭代器已经知道了集合中集合元素的个数和顺序
//那么我们正常迭代时是没有问题的，关键是如果我们对集合进行增删元素，那么就改变了集合原有的长度。
//从而打乱了迭代器预先知道的元素个数，或者说打乱了迭代器的迭代顺序，就会出现ConcurrentModificationException 并发修改异常
//解决方式1：还是要使用迭代器，迭代途中想要增删元素，使用迭代器自己的方法进行元素的增删。
//解决方式2：不要使用迭代器来遍历，使用for循环进行遍历，在遍历途中可以对元素进行增删。
System.out.println("-------------------------");
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
//向下转型
String str= (String) obj;
if (str.equals("javaee")){
list.remove("javaee");
}
}
System.out.println(list);
}
}
道了集合中集合元素的个数和顺序
//那么我们正常迭代时是没有问题的，关键是如果我们对集合进行增删元素，那么就改变了集合原有的长度。
//从而打乱了迭代器预先知道的元素个数，或者说打乱了迭代器的迭代顺序，就会出现ConcurrentModificationException 并发修改异常
//解决方式1：还是要使用迭代器，迭代途中想要增删元素，使用迭代器自己的方法进行元素的增删。
//解决方式2：不要使用迭代器来遍历，使用for循环进行遍历，在遍历途中可以对元素进行增删。
System.out.println("-------------------------");
for (int i = 0; i < list.size(); i++) {
Object obj = list.get(i);
//向下转型
String str= (String) obj;
if (str.equals("javaee")){
list.remove("javaee");
}
}
System.out.println(list);
}
}
扫一扫
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
