1.Collection下面派生了两个常用的子接口：List：可重复集并且有序，Set：不可重复集。
c.size(); c.isEmpty(); c.clear();
package day08;
import java.util.ArrayList;
import java.util.Collection;
/**
* 集合框架
* java提供了一套用于维护一组元素的数据结构解决方案——集合
* java.util.Collection
* Collection是所有集合的顶级接口，规定了所有集合都应具备的功能。
*
* Collection下面派生了两个常用的子接口：
* List：可重复集并且有序
* Set：不可重复集
* 重复与否指的是元素是否可以重复，
* 而重复的标准判断是依靠元素自身equals比较的结果。
* 比较为true则认为两个元素是重复元素。set集合不允许出现重复元素。
* @author soft01
*
*/
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
/*
* boolean add(E e)
* 向当前集合中添加元素，成功添加会返回true
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
/*
* int size()
* 返回当前集合的元素数量
*/
int size = c.size();
System.out.println("size:"+size);
/*
* 判断当前集合是否为空集（不含有元素）
*/
boolean isEmpty = c.isEmpty();
System.out.println("isEmpty:"+isEmpty);
/*
* void clear()
* 清空集合
*/
c.clear();
System.out.println("集合已清空");
System.out.println(c);//[]
System.out.println("size："+c.size());
System.out.println("isEmpty:"+c.isEmpty());
}
}
2.改其中一个点。
前面已经创建过的类。
package day02;
/**
* Point 设计目的：表示直角坐标系上的一个点
* 特征：x,y两个值
*
* 使用这个类测试作为Object子类对相关方法的重写原则。
*
* java中所有的类都继承自Object，
* 当一个类没有使用extends显示继承任何一个类时，
* 编译器在编译该类后默认会让其继承自Object.
* @author soft01
*
*/
public class Point {
private int x;
private int y;
public Point() {
}
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;
}
/**
* 当一个对象的toString被使用，那么就应当重写该方法。
* 因为Object提供的该方法返回的句柄对实际开发的价值不大。
* 重写toString方法的原则是返回的字符串中应当包含当前对象
* 需要让外界了解的属性信息。
* 格式没有要求，将来按照实际工作中的需求定。
*
*/
public String toString() {
return "("+x+","+y+")";
}
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(obj == this) {
return true;
}
if(obj instanceof Point) {
Point p =(Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}
}
package day08;
import java.util.ArrayList;
import java.util.Collection;
import day02.Point;;
/**
* 集合存放的元素的引用（地址）
* @author soft01
*
*/
public class CollectionDemo2 {
public static void main(String[] args) {
Point p = new Point(1,2);
Collection c = new ArrayList();
c.add(p);
System.out.println("p:"+p);
System.out.println("c:"+c);
p.setX(2);
System.out.println("p:"+p);
System.out.println("c:"+c);//[(2,2)]
}
}
3.判断当前集合是否包含给定元素c.contains(p)。
package day08;
import java.util.ArrayList;
import java.util.Collection;
import day02.Point;
/**
* boolean contains(E e)
* 判断当前集合是否包含给定元素
* @author soft01
*
*/
public class Collection_contains {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(2,3));
c.add(new Point(3,4));
c.add(new Point(4,5));
System.out.println(c);
Point p = new Point(1,2);
/*
* 判断集合c是否包含p对象
* 集合contains方法判断包含的逻辑为：
* 当前集合元素只要有与给定对象equals比较为true的，
* 则认为当前集合包含还元素
*
* 作为集合的元素，它的toString,equals方法会影响集合很多方法的结果。
* 所以若集合存放的是我们自己写的类，那么就要妥善重写这两个方法。
*/
boolean contains = c.contains(p);
System.out.println("是否包含："+contains);
}
}
4.删除集合元素c.remove(p)。
package day08;
import java.util.ArrayList;
import java.util.Collection;
import day02.Point;
/**
* 删除集合元素
* @author soft01
*
*/
public class Collection_remove {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(3,4));
System.out.println(c);
Point p = new Point(3,4);
/*
* boolean remove(E e)
* 从集合中删除给定元素，删除成功则返回true
*
* 删除逻辑为：集合会顺序用给定元素与集合元素
* 进行equals比较，删除第一个比较为true的元素。
*/
c.remove(p);
System.out.println(c);
}
}
5.集合操作:c1.addAll(c2); c1.containsAll(c3); c1.removeAll(c3);
package day08;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合操作
* @author soft01
*
*/
public class Collection_addAll {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("java");
c1.add("c++");
c1.add(".net");
System.out.println(c1);
Collection c2 = new HashSet();
c2.add("android");
c2.add("ios");
c2.add("java");
System.out.println(c2);
/*
* 将c2集合中的所有元素存入c1
* boolean addAll(Collection c)
* 将给定集合的所有元素添加到当前集合中
* 添加后当前集合元素发生改变则返回true
*/
c1.addAll(c2);
System.out.println(c1);
System.out.println(c2);
Collection c3 = new ArrayList();
c3.add("java");
c3.add("ios");
System.out.println("c3:"+c3);
/*
* boolean containsAll(Collection c)
* 判断当前集合是否包含给定集合中的所有元素
*/
boolean contains = c1.containsAll(c3);
System.out.println("c1包含c3所有元素："+contains);
/*
* boolean removeAll(Collection c)
* 删除当前集合中与给定集合中的公有元素删交集
*/
c1.removeAll(c3);
System.out.println(c1);
}
}
6.集合的遍历——迭代器（Iterator）
package day08;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 集合的遍历
* Collection提供了统一的遍历集合元素的方式：
* 迭代器模式（Iterator）
* 对应办法：
* Iterator iterator()
* 该方法会返回一个可以遍历当前集合元素的迭代器实例。
*
* java.util.Iterator接口
* 该接口规定了迭代器用来遍历集合的相关方法。
* 不同的集合都实现了一个可以用于遍历自身的迭代器实现类。
* 我们无需记住每种集合提供的迭代器实现类的名字，
* 只要将它们以Iterator接口看待，
* 可以调用相关遍历方法达到遍历集合的目的就可以了。
*
* 迭代器遍历集合遵循步骤：
* 问，取，删（其中删除不是必须操作）
* @author soft01
*
*/
public class Collection_iterator {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
System.out.println(c);
Iterator it = c.iterator();
/*
* boolean hasNext()
* 通过迭代器判断集合是否还有元素可以遍历
*/
while(it.hasNext()) {
/*
* E next()
* 获取集合中下一个元素
*/
String str = (String)it.next();
System.out.println(str);
if("#".equals(str)) {
/*
* 在使用迭代器遍历集合的过程中
* 不能通过集合的方法增删元素，
* 否则会发生迭代器错误。
*
* 迭代器的remove方法可以将通过
* next方法取出的元素从集合中删除
*/
it.remove();
}
}
System.out.println(c);
}
}
7. 泛型 JDK1.5后推出的一个新特性,泛型可以不指定，若不指定则为原型Object。
<E>——泛型参数
package day08;
/**
* 泛型 JDK1.5后推出的一个新特性
* 泛型又称为参数化类型，允许使用方在实例化对象时
* 传入具体类型来决定当前类中泛型的实际类型。
* @author soft01
*
*/
public class Point<E> {
private E x;
private E y;
public Point() {
}
public Point(E x, E y) {
super();
this.x = x;
this.y = y;
}
public E getX() {
return x;
}
public void setX(E x) {
this.x = x;
}
public E getY() {
return y;
}
public void setY(E y) {
this.y = y;
}
/**
* 当一个对象的toString被使用，那么就应当重写该方法。
* 因为Object提供的该方法返回的句柄对实际开发的价值不大。
* 重写toString方法的原则是返回的字符串中应当包含当前对象
* 需要让外界了解的属性信息。
* 格式没有要求，将来按照实际工作中的需求定。
*
*/
public String toString() {
return "("+x+","+y+")";
}
public boolean equals(Object obj) {
if(obj == null) {
return false;
}
if(obj == this) {
return true;
}
if(obj instanceof Point) {
Point p =(Point)obj;
return this.x==p.x&&this.y==p.y;
}
return false;
}
}
package day08;
public class TestPoint {
public static void main(String[] args) {
Point<Integer> p1 = new Point<Integer>(1,2);
System.out.println("p1:"+p1);
p1.setX(2);
System.out.println("p1:"+p1);
int x1 = p1.getX();
System.out.println("x1:"+x1);
Point<Double> p2 = new Point<Double>(1.1,2.2);
System.out.println("p2:"+p2);
p2.setX(2.2);
System.out.println("p2:"+p2);
double x2 = p2.getX();
System.out.println("x2:"+x2);
Point<String> p3 = new Point<String>("一","二");
System.out.println("p3:"+p3);
p3.setX("二");
System.out.println("p3:"+p3);
String x3 = p3.getX();
System.out.println("x3:"+x3);
}
}
8.集合中广泛使用泛型，而泛型是用来约束集合中的元素类型。
package day08;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 集合中广泛使用泛型，而泛型是用来约束集合中的元素类型。
* @author soft01
*
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c);
Iterator<String> it = c.iterator();
while(it.hasNext()) {
String str = it.next();
System.out.println(str);
}
}
}
9.JDK1.5之后推出的又一个新特性：增强for循环，又称为新循环，for each
用于数组:
package day08;
/**
* JDK1.5之后推出的又一个新特性：
* 增强for循环，又称为新循环，for each
*
* 新循环并非新的语法，它不是JVM认可的，而是编译器认可的。
* 作用是方便遍历集合或数组。
* @author soft01
*
*/
public class NewForDemo1 {
public static void main(String[] args) {
String[] array = {"one","two","three","four"};
for(int i=0;i<array.length;i++) {
String str = array[i];
System.out.println(str);
}
for(String str:array) {
System.out.println(str);
}
}
}
用于集合：
package day08;
import java.util.ArrayList;
import java.util.Collection;
/**
* 使用新循环遍历集合
* @author soft01
*
*/
public class NewForDemo2 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
/*
* 编译器在编译源程序时会将新循环遍历集合
* 改为使用迭代器遍历方式。
* 所以新循环在遍历集合时不能通过集合方法增删元素。
*/
for(String str : c) {
System.out.println(str);
}
System.out.println(c);
}
}
99
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
