Collection c = new ArrayList();
* boolean add(E e)
* 将当前集合中添加给定的元素
* 若成功添加则返回true
c.add("one");
c.add("two");
* int size()
* 获取当前集合中的元素个数
c.size();
* boolean isEmpty()
* 判断当前集合是否不包含任何元素
* 当集合中没有元素时返回true
boolean isEmpty = c.isEmpty();
* void clear()
* 清空集合元素
c.clear();
* boolean contains(E e)
* 判断当前集合是否包含给定元素，包含则返回true
* 判断依据是看给定的元素与集合中现有的元素是否
* 存在equals比较为true的，有则认为包含!
boolean contains = c.contains(e);
* 集合提供了一个方法可以删除集合中的现有元素
* boolean remove(E e)
* 将给定的元素从集合中删除，成功删除返回true
* 删除元素的判断依据是，删除当前集合中第一个与
* 给定元素equals比较为true的。
c.remove(e);
* 并集
* boolean addAll(Collection c)
* 将给定的集合中的所有元素添加到当前集合中
* 当执行完毕后，当前集合中的元素发生了改变
* 就返回true
c2.addAll(c1);
* 判断当前集合中是否包含给定集合里的所有
* 元素，全部包含则返回true。这里判断依据
* 依然是依靠元素的equals比较的。
* boolean containsAll(Collection c)
boolean contains = c1.containsAll(c3);
* 由于集合的具体实现类各不相同，Set集合大部分实现
* 又是无序的，所以不能像数组那样根据下标位置获取
* 具体的某一个元素。
* 集合提供了统一的获取集合元素方式:遍历集合，而
* 遍历是使用迭代器来完成的。
* java.util.Iterator是迭代器的接口，定义了用于遍历
* 集合的相关方法。不同的集合都实现了一个可以遍历自身
* 的迭代器实现类。我们无需记住实现类的名字，只当是
* 迭代器使用即可。
* 迭代器迭代元素需要遵循:问，取，删。这个步骤。
* 其中删除不是必须的。
* 若需要遍历集合，可以调用集合的方法:
* Iterator iterator()
* 该方法会返回可以遍历当前集合的迭代器。
Iterator it = c.iterator();
* boolean hasNext()
* 询问迭代器，其遍历的集合是否还有元素没有
* 遍历过，有则返回true
while(it.hasNext()){
* E next()
* 取出集合中下一个元素。
String str = (String)it.next();
/*
* 删除"#"
*/
if("#".equals(str)){
/*
* 在使用迭代器遍历集合的过程中，不能通过
* 集合的方法改变集合元素，否则可能抛出异常
*/
// c.remove(str); 集合的方法
/*
* 删除的是刚通过next()方法取出的元素。
*/
it.remove();//迭代器方法
}
}
* java 5.0以后推出了一个新的特性:增强for循环
* 又叫做:新循环，增强循环，for each
* 新循环不能代替传统循环重复工作的需求。
* 新循环是用来遍历集合或数组的。
String[] array
= new String[]{"one","two","three"};
for(String str:array){
System.out.println(str);
}
* 新循环并不是JVM认可的新语法。而是编译器认可
* 的。编译器在编译源程序时若发现我们使用新循环
* 来遍历集合时，会将代码改变为使用迭代器的方式
* 遍历集合。所以新循环遍历集合本质上就是迭代器
* 遍历。
* 所以新循环在遍历集合的过程中不允许通过集合的
* 方法修改元素数量。
for(Object obj:c){
if("#".equals(obj)){
c.remove(obj);//错误
i.remove(obj);//没有显示迭代，错误
}
}
* List集合
* 有序集，可重复集。
* List的特点是可以像数组一样，根据下标操作元素。
* 所以List提供了一些独有的方法。
* 常用实现类:
* ArrayList:内部由数组实现，查询快。
* LinkedList:内部由链表实现，增删快。
List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
* E get(int index)
* 获取指定下标对应的元素。
String str = list.get(1);
//通过下标操作遍历集合
for(int i=0;i<list.size();i++){
str = list.get(i);
System.out.println(str);
}
* E set(int index,E e)
* 将给定的元素设置到指定的位置上，返回值为
* 原位置上的元素。所以该操作时替换元素操作
String old = list.set(1, "2");
* List提供的另一对方法:
* void add(int index,E e)
* 向指定位置插入给定元素，原位置及后续元素顺序向后
* 移动
*
* E remove(int index)
* 删除并返回给定位置的元素。
List<String> list = new LinkedList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
* void add(int index,E e)
list.add(2,"3");
* E remove(int index)
* 删除并返回给定位置的元素。
String old = list.remove(3);
* 集合转换为数组
* Collection中提供了一个方法toArray
* 允许我们将现有的集合转换为数组。
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
// Object[] array = c.toArray(); 转换的是Object数组，所以一般不用这种，而用下面的那种
String[] array
= c.toArray(new String[c.size()]);
* 数组转换为集合
* 使用Arrays的静态方法asList()
* 需要注意，数组只能转换为List集合。不能转换为Set
* 原因在于:
* 1:Set大部分是无序实现
* 2:Set不允许存放重复元素，所以转换后可能丢失元素。
String[] array = new String[]{"one","two","three"};
List<String> list = Arrays.asList(array);
* 修改该集合元素内容，原数组内容也会发生改变
list.set(0, "1");
//数组第一个元素也变为了"1"
* 对于由数组转换的集合来说，添加新元素是不受支持的!所以下面代码会抛出异常
list.add("four");
* 所有的集合都支持一个构造方法，参数要求传入另一个集合。
* 这个构造方法的作用是:
* 创建当前集合的同时将给定的集合中的所有元素添加到当前集合中。
List<String> list1 = new ArrayList<String>(list);
* 获取List集合中的子集
List<Integer> list = new ArrayList<Integer>();
for(int i=0;i<10;i++){
list.add(i);
}
//[0,1,2,3,4,5,6,7,8,9]
* List subList(int start,int end)
* 获取当前集合中给定范围内的部分子集。
List<Integer> subList = list.subList(3, 8);
* 对子集的任何操作都会影响原集合
* 清空子集，原集合中该部分内容也被删除。
* 泛型
* JDK5.0开始支持的新特性
* 泛型是参数化类型，可以对一个类中的属性，
* 方法的参数，方法的返回值类型进行约束，
* 在使用时指定类型。
public class Point<T> {
private T x;
private T y;
public Point(){
}
public Point(T x, T y) {
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
public static void main(String[] args) {
Point<Integer> p1
= new Point<Integer>(1,2);
int x1 = p1.getX();
Point<Double> p2
= new Point<Double>(1.1,2.2);
double x2 = p2.getX();
Point<String> p3
= new Point<String>("1","2");
String x3 = p3.getX();
}
}
* 泛型的注意事项
* 当使用一个具有泛型的类时，若不指定，则就
* 按照默认的Object作为实际类型
* 泛型在集合中的应用
* 集合中的泛型是用来约束集合中元素的类型。
Collection<String> c = new ArrayList<String>();
c.add("one");
* 迭代器也支持泛型，泛型与该迭代器遍历的集合
* 的泛型类型一致即可。
Iterator<String> it = c.iterator();
while(it.hasNext()){
String str = it.next();
}
* Collections: 集合的工具类
* 该类提供了若干静态方法，可以方便操作集合。
* 其中sort方法是用来排序List集的。进行自然排序
* sort会对给定的List集合中的元素进行自然排序
* 即:从小到大的顺序
* Collections.sort(list);
* 面试题：
* Collection与Collections的区别?
* 或分别说明它们
* Collections的sort方法若希望对集合进行
* 排序，必须保证集合中的元素是可比较大小的。
* 所以要求元素必须实现Comparable接口，并
* 重写其中的比较大小方法，才可以进行排序。
* 虽然sort方法可以对集合中的元素进行自然排序
* 但是必须要求元素实现Comparable接口，这就出现
* 了由于想使用排序功能而必须改变我们定义的类的
* 内容，这中现象称为"侵入性"。
* 当集合中存放的是自定义类型元素时，使用Collections的sort方法排序的注意事项:
*
* 当前元素若希望可以比较大小，需要实现Comparable
* 接口
* Comparable支持泛型，而泛型的实际类型就是当前
* 类。意思是说，哪个类实现Comparable接口，泛型
* 就是哪个类。
public class Point implements Comparable<Point>{
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String toString(){
return "(" + x + "," + y + ")";
}
/**
* CompareTo方法的作用是使当前对象与给定的对象o进行比较大小。
* 返回值不关注具体值，而是关注取值范围:
* 当返回值>0:当前对象比参数对象大
* 当返回值<0:当前对象比参数对象小
* 当返回值=0:两个对象相等
*/
public int compareTo(Point o) {
int len = this.x*this.x+this.y*this.y;
int olen = o.x*o.x+o.y*o.y;
return len-olen;
}
}
* 字符串String实现了Comparable接口
* 排序规则:按照首字母的编码比大小。
* Collections的重载sort方法要求我们传入两个
* 参数:
* 1:待排序的集合
* 2:比较器
* 通常有两种情况会使用该方法排序集合:
* 1:元素已经实现了Comparable接口，但是比较大小
* 的规则不能满足我们对于排序的需求时
* 2:元素没有实现Comparable接口，并且也不希望为
* 了这里排序而强制修改元素，要求其实现接口时
*
// MyComparator com = new MyComparator();
Comparator<String> com
= new Comparator<String>(){
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
};
Collections.sort(list,com);
class MyComparator implements Comparator<String>{
/**
* 字符串比较大小的规则:
* 字符数量多的大
*/
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
}
时间： 2024-10-22 13:05:52