集合
概念
用于存储多个对象的单一对象(容器,数据结构).存储的数据叫做元素,注意元素只能是引用类型,不可以存储基本数据类型.
用于模拟现实生活中的存储容器,因此集合类型不单单是一种.是有很多类型的,可以设计成存储各种存储的数据结构,这些结构统称为集合框架.
集合内存储的是对象的地址信息.
且子类中重写了toString方法.
JDK1.5新特性
在JDK1.5之前,容器可以存储Object的任何子类型,但是对元素进行操作时,比如调用元素的方法,此时必须知道元素的类型,因此在编程中增加了大量的代码来进行强制转换.因此JDK1.5开始支持一个新特性:泛型,用于规定容器中存储的元素的类型.此机制可以在编译期间就判断元素的类型.
与数组的区别
数组可以存储基本数据类型,也可以存储引用数据类型.而集合不能存储基本数据类型.
集合框架
包含许多接口,抽象类,实现类等,用来满足我们所需要的用于存储数据的数据结构.
interface Collection
集合框架的顶级父接口,用来定义常用的方法.子类需要实现相应的方法逻辑.
与Collections的区别
Collections是集合的工具类,里面定义了许多用于操作集合对象的工厂方法.
常用方法
boolean add(E e):将对象E添加到容器中.
int size():返回集合内的元素数.
boolean addAll(Collection c):将c内元素的地址添加到此集合中.
void clear():清除集合内的元素.
boolean contains(Object obj):查看集合内是否包含与obj相同的元素.
boolean containsAll(Collection c):查看此集合内是否包含集合c中的所有元素.
boolean isEmpty():用于判断集合是否为空.为空返回true.
boolean remove(Object obj):集合中删除元素obj.
boolean retainAll(Collection c):仅保留两个集合的共有元素.
<T> T[] toArray(T[] a):将集合转换为数组.
Collection接口方法的相关示例代码如下:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class Tests {
public static void main(String[] args) {
Collection<String> c=new ArrayList<String>();
Collection<String> c1=new ArrayList<String>();
/*添加元素 boolean add(E e)*/
c.add("A");c.add("B");c.add("C");c.add("D");
c1.add("E");c1.add("F");
System.out.println("集合c:"+c);
System.out.println("集合c1:"+c1);
/*集合c的元素数 int size();*/
System.out.println("集合c的元素数:"+c.size());
/*添加集合boolean addAll(Collection c) */
c.addAll(c1);
System.out.println("添加集合后的c:"+c);
/*清空集合 void clear()*/
c1.clear();
System.out.println("清空后的集合c1:"+c1);
/*是否有相同元素 boolean contains(Object obj)*/
String str="b";
System.out.println("集合c中是否包含str:"+c.contains(str));
/*是否包含集合全部元素 boolean containsAll(Collection c)*/
Collection<String> c2=new ArrayList<String>();
c2.add("B");c2.add("E");c2.add("F");
System.out.println("c是否包含集合c2:"+c.containsAll(c2));
/*判断是否为空 boolean isEmpty()*/
System.out.println("集合c1是否为空:"+c1.isEmpty());
/*移除某一元素 boolean remove(Object o)*/
String str1="C";
c.remove(str1);
System.out.println("集合c移除str1:"+c);
/*移除集合中的共有元素 boolean removeAll(Collection c)*/
c.removeAll(c2);
System.out.println("移除集合c2中共有元素后的c1:"+c);
c.addAll(c2);
/*保留共有元素 boolean retainAll(Collection c)*/
Collection<String> c3=new ArrayList<String>();
c3.add("D");c3.add("E");c.add("F");
c.containsAll(c3);
System.out.println("保留与c3共有的元素的集合c"+c);
/*转换为数组 <T> T[] toArray(T[] a)*/
String[] strArr=c.toArray(new String[0]);
System.out.println("集合c转换为数组"+Arrays.toString(strArr));
}
}运行结果:
集合c:[A, B, C, D]
集合c1:[E, F]
集合c的元素数:4
添加集合后的c:[A, B, C, D, E, F]
清空后的集合c1:[]
集合c中是否包含str:false
c是否包含集合c2:true
集合c1是否为空:true
集合c移除str1:[A, B, D, E, F]
移除集合c2中共有元素后的c1:[A, D]
保留与c3共有的元素的集合c[A, D, B, E, F, F]
集合c转换为数组[A, D, B, E, F, F]interface List 列表
是Collection的子接口此接口的实现类对应的实现类都是有序的,可以重复的,重复与否与元素的equals()有关,有对应的索引(下标)标记位置,从0开始.存入的元素可以是同一个,也可以是内容相同的不同对象.
由于存在下标,所以可以对指定元素通过下标进行操作.
常用方法
void add(int index,E element):将某一元素插入至此集合的下标index出,剩下的元素依次向后移动.
E get(int index):返回指定下标位置的元素.
int indexOf(Object obj):返回指定元素第一次出现的位置,若没有则返回-1.
E set(int index,E new Element):使用新元素element替换下标index的元素,返回原来的元素.
boolean remove(int index):移除此集合中下标为index的元素,移除后底层数组缩容.
List<E> subList(int fromIndex,int endIndex):截取此集合中fromIndex下标到endIndex下标(不含endIndex)的元素.
PS:此方法不会在堆中产生新的集合对象,变量引用的是父集的一部分.
List相关方法的示例代码:
import java.util.ArrayList;
import java.util.List;
public class Tests {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("A");list.add("C");list.add("D");list.add("E");
/*向指定位置添加元素 void add(int index,E element)*/
list.add(1,"B");
System.out.println("像第二个位置添加元素后的list:"+list);
/*返回指定下标的元素 E ger(int index)*/
System.out.println("取出的list的第四个元素:"+list.get(3));
/*返回指定元素第一次出现的位置下标 int indexOf(Object obj)*/
System.out.println("元素C第一次出现的下标为:"+list.indexOf("C"));
System.out.println("元素F第一次出现的下标为:"+list.indexOf("F"));
/*使用新元素替换指定位置的元素 E set(int index,E element)*/
System.out.println("被移除的元素:"+list.set(2,"G"));
System.out.println("替换元素后的list:"+list);
/*移除指定位置元素 boolean remove(int index)*/
list.remove(1);
System.out.println("移除第二个元素后的list:"+list);
/*截取一部分 List<E> subList(int fromIndex,int endIndex)*/
System.out.println("截取2至4号元素list:"+list.subList(1,4));
}
}运行结果:
像第二个位置添加元素后的list:[A, B, C, D, E]
取出的list的第四个元素:D
元素C第一次出现的下标为:2
元素F第一次出现的下标为:-1
被移除的元素:C
替换元素后的list:[A, B, G, D, E]
移除第二个元素后的list:[A, G, D, E]
截取2至4号元素list:[G, D, E]数组与集合之间的转换
集合转数组
Object[] toArray();
E[] toArray(E e);
数组转集合
List Arrays.asList(数组参数);
注意:数组转成的集合不能进行增删操作,否则报UnsupportedOperationException.但是可以进行改操作,数组对应元素亦会被修改.若想成功进行增删操作,可以将元素存入新集合中.
interface Iterator迭代器
作用是用来遍历几何元素,提供一个方法
Iterator iterator();
Collection 的实现类使用内部类定义了迭代器子类.
迭代器提供了统一的方法,用于遍历集合元素.
常用方法
boolean hasNext():判断集合中是否有下一个元素.
E next():取出集合中的下一个元素.
void remove():移除元素.
注意:在使用迭代器堆集合进行遍历是,不能使用集合的remove()进行移除.
必须使用迭代器自己提供的remove()才可以.
迭代器的示例代码:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Tests {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("A");list.add("B");list.add("C");list.add("D");list.add("E");
Iterator<String> i=list.iterator();
/*使用迭代器遍历集合元素*/
while (i.hasNext()){
String str=i.next();
System.out.print(str+" ");
}
System.out.println();
/*迭代器的删除方法 void remove()*/
Iterator<String> i1=list.iterator();
while (i1.hasNext()){
String str=i1.next();
if ("C".equals(str))
i1.remove();
}
System.out.println("删除元素后的list:"+list);
}
}
运行结果:
A B C D E
删除元素后的list:[A, B, D, E]
增强for循环(foreach)
for(元素类型 变量名:要遍历的集合或数组.){循环体}
底层使用了迭代器.
注意,foreach循环无法使用下标,只能进行遍历.
增强for循环示例代码:
import java.util.ArrayList;
import java.util.List;
public class Tests {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("A");list.add("B");list.add("C");list.add("D");list.add("E");
for (String str:list) {
System.out.println(str);
}
}
}运行结果:
A
B
C
D
E