@liayun
2016-06-01T23:09:09.000000Z
字数 14131
阅读 1906
java基础
为什么会出现这么多的容器呢?
答:因为每一个容器对数据的存储方式都有不同。这个存储方式称之为:数据结构。
集合中的最大接口——Collection,可以通过查看JDK帮助文档,了解Collection接口中的最共性的方法。
创建一个集合容器,使用Collection接口的子类——ArrayList
ArrayList al = new ArrayList();
al.add("java01"); // add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
注意:
1. add方法的参数类型是Object,以便于接受任意类型。
2. 集合中存储的都是对象的引用(地址)。
al.remove("java02");
al.clear();
System.out.println("java03是否存在:"+al.contains("java03"));
System.out.println("集合是否为空?"+al.isEmpty());
retainAll()
:取交集removeAll()
:移除交集
public static void method() {
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");
// al1.retainAll(al2); // 取交集,al1中只会保留和al2中相同的元素
al1.removeAll(al2); // al1中移除al1和al2的交集
System.out.println("al1:"+al1);
System.out.println("al2:"+al2);
}
现重点描述迭代器(Iterator)。
什么是迭代器呢?
答:其实就是集合的取出元素的方式。
Iterator
的初步解释:就是把取出方式定义在了集合的内部,这样取出方式就可以直接访问集合内部的元素,那么取出方式就被定义成了内部类。而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都有共性内容——判断和取出,那么可以将这些共性抽取,那么这些内部类都符合一个规则,该规则是Iterator
。
如何获取集合的取出对象呢?
答:通过一个对外提供的方法:iterator()
。
因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
例,
public static void sop(Object obj) {
System.out.println(obj);
}
public static void method_get() {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
/*
Iterator it = al.iterator(); // 获取迭代器,用于取出集合中的元素
while(it.hasNext()) {
sop(it.next());
}
*/
// 开发时,这样写
for (Iterator it = al.iterator(); it.hasNext(); ) {
sop(it.next());
}
}
Collection接口有两个子接口:List(列表)
,Set(集)
。
List特有方法:凡是可以操作角标的方法都是该体系特有的方法。
add(index, element);
addAll(index, Collection);
remove(index);
set(index, element);
get(index);
subList(from, to);
listIterator();
例,
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(1, "java09");
al.remove(2);
al.set(2, "java007");
System.out.println("get(1):"+al.get(1));
for (int x = 0; x < al.size(); x++) {
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while(it.hasNext()) {
System.out.println("next:"+it.next());
}
System.out.println("index = "+al.indexOf("java02"));
List sub = al.subList(1, 3);
System.out.println("sub="+sub);
现在我们来思考这样一个问题:在迭代过程中,准备添加或者删除元素。
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
// 在迭代过程中,准备添加或者删除元素
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(obj.equals("java02"))
al.add("java008"); // 出现并发修改异常
System.out.println("obj="+obj);
}
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生并发修改异常(ConcurrentModificationException)。
迭代器还有另一个方法:remove()
,我们可以试着用一下:
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(obj.equals("java02"))
it.remove(); // 将java02的引用从集合中删除了,但java02的引用还被obj使用
System.out.println("obj="+obj); // 注意:虽然移除掉了"java02",但还能输出
}
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator的方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口listIterator
——List集合特有的迭代器(listIterator)。该接口只能通过List
集合的listIterator()
获取。
例,
public static void main(String[] args) {
// 演示列表迭代器
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
System.out.println(al);
ListIterator li = al.listIterator();
while(li.hasNext()) {
Object obj = li.next();
if(obj.equals("java02"))
// li.add("java009");
li.set("java006");
}
while(li.hasPrevious()) {
System.out.println("pre:"+li.previous());
}
System.out.println(al);
}
枚举就是Vector特有的取出方式,通过API帮助文档可发现枚举和迭代器很像。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长,所以被迭代器取代了,枚举郁郁而终了。
迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举),例:
import java.util.*;
class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
}
LinkedList特有方法:
addFirst();
addLast();
getFirst();
getLast();
removeFirst();
removeLast();
在JDK1.6出现了替代方法:
addFirst();
--->offerFirst();
addLast();
--->offerLast();
getFirst();
--->peekFirst();
getLast();
--->peekLast();
removeFirst();
--->pollFirst();
removeLast();
--->pollLast();
例,
import java.util.*;
class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
// sop(link.getFirst());
// sop(link.getFirst());
// sop(link.getLast());
// sop(link.removeFirst());
// sop(link.removeFirst());
// sop("size="+link.size());
while(!link.isEmpty()) {
sop(link.removeLast());
}
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
面试题:使用LinkedList模拟一个堆栈或者队列数据结构(必须会)。
解:
分析:
堆栈:先进后出——如同一个杯子。
队列:先进先出(First In First Out)FIFO——如同一个水管。
import java.util.*;
// 基于LinkedList来描述
class DuiLie {
private LinkedList link;
DuiLie() {
link = new LinkedList();
}
public void myAdd(Object obj) {
link.addFirst(obj);
}
public Object myGet() {
return link.removeLast(); // 模拟队列
// return link.removeFirst(); // 模拟堆栈
}
public boolean isNull() {
return link.isEmpty();
}
}
class LinkedListTest {
public static void main(String[] args) {
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
System.out.println(dl.myGet());
}
}
练习一:去除ArrayList集合中的重复元素(集合中元素是字符串)。
import java.util.*;
class ArrayListTest {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop(al);
al = singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al) {
// 定义一个临时容器
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(!newAl.contains(obj)) // 判断临时容器中是否包含传递进来的容器中的元素
newAl.add(obj);
}
return newAl;
}
}
练习二:将自定义对象作为元素存到ArrayList集合中,并去除重复元素。比如:存人对象。同姓名同年龄,视为同一个人,为重复元素。
解:
思路:
import java.util.*;
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object obj) {
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"..."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
class ArrayListTest2 {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("lisi01", 30)); // add(Object obj); Object obj = new Person("lisi01", 30);
al.add(new Person("lisi02", 32));
al.add(new Person("lisi02", 32));
al.add(new Person("lisi04", 35));
al.add(new Person("lisi03", 33));
al.add(new Person("lisi04", 35));
al = singleElement(al);
Iterator it = al.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
public static ArrayList singleElement(ArrayList al) {
// 定义一个临时容器
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(!newAl.contains(obj)) // contains底层用的是equals()
newAl.add(obj);
}
return newAl;
}
}
通过以上示例,说明contains底层用的是equals()。
ArrayList去除重复元素的示意图:
再来看以下代码:
import java.util.*;
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object obj) {
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"..."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
class ArrayListTest2 {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("lisi01", 30)); // add(Object obj); Object obj = new Person("lisi01", 30);
al.add(new Person("lisi02", 32));
al.add(new Person("lisi04", 35));
al.add(new Person("lisi03", 33));
sop("remove 03:"+al.remove(new Person("lisi03", 33))); // remove底层用的也是equals()
Iterator it = al.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
通过以上示例,说明remove底层用的也是equals()。
结论:List集合判断元素是否相同,依据的是元素的equals方法。
通过查看JDK文档,发现Set集合的功能和Collection的是一致的。
Hashset是如何保证元素的唯一性的呢?
答:是通过元素的两个方法,hashCode()
和equals()
来完成的。如果元素的HashCode值
相同,才会判断equals()
是否为true。如果元素的HashCode值
不同,不会调用equals()
。
例,
import java.util.*;
class HashSetDemo {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
HashSet hs = new HashSet();
sop(hs.add("java01")); // true
sop(hs.add("java01")); // false
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext()) {
sop(it.next());
}
}
}
练习:往hashSet集合中存入自定义对象(人)。姓名和年龄相同为同一个人,重复元素。
解:
import java.util.*;
class HashSetTest {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add(new Person("a1", 11));
hs.add(new Person("a2", 12));
hs.add(new Person("a3", 13));
hs.add(new Person("a2", 12));
hs.add(new Person("a4", 14));
// sop(hs.contains(new Person("a1", 11)));
// hs.remove(new Person("a4", 13));
Iterator it = hs.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int hashCode() {
System.out.println(this.name+".....hashCode");
return name.hashCode() + age * 39; // 39是一个任意的数字
}
public boolean equals(Object obj) {
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"...equals..."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
Hashset保证元素的唯一性示意图:
注意:对于判断元素是否存在,以及删除、添加等操作,依赖的方法是元素的hashCode()
和equals()
方法。
例,需求:往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。
解:
int compareTo(T o)
:比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。TreeSet排序的第一种方式:
import java.util.*;
class Student implements Comparable { // 该接口强制让学生具备比较性
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int compareTo(Object obj) {
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"...compareTo..."+s.name);
if(this.age > s.age)
return 1;
if(this.age == s.age) { // 当年龄相同时,再判断一下姓名的自然排序
return this.name.compareTo(s.name);
}
return -1;
}
}
class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02", 22));
ts.add(new Student("lisi007", 20));
ts.add(new Student("lisi09", 19));
ts.add(new Student("lisi08", 19));
Iterator it = ts.iterator();
while(it.hasNext()) {
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
二叉树原理:
记住,排序时,当主要条件相同时,一定判断一下次要条件。
思考:需求元素变为怎么存进去的就怎么取出来的,怎么办?
这时可依据二叉树原理来实现,只要让compareTo()
方法返回正数即可,比如:
import java.util.*;
class Student implements Comparable { // 该接口强制让学生具备比较性
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int compareTo(Object obj) {
return 1;
}
}
class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02", 22));
ts.add(new Student("lisi007", 20));
ts.add(new Student("lisi09", 19));
ts.add(new Student("lisi08", 19));
Iterator it = ts.iterator();
while(it.hasNext()) {
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
TreeSet排序的第二种方式:
当元素自身不具备比较性时,或者具备的比较性不是所需要的,这时就需要让容器自身具备比较性。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序都存在时,以比较器为主。
定义一个类实现Comparator接口,覆盖compare()方法。
int compare(T o1, T o2)
:比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
import java.util.*;
class Student implements Comparable { // 该接口强制让学生具备比较性
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int compareTo(Object obj) {
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
// System.out.println(this.name+"...compareTo..."+s.name);
if(this.age > s.age)
return 1;
if(this.age == s.age) {
return this.name.compareTo(s.name);
}
return -1;
}
}
class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new MyCompare()); // 此时学生对象自己具备的比较方式不是我们所需要的
ts.add(new Student("lisi02", 22));
ts.add(new Student("lisi02", 21));
ts.add(new Student("lisi007", 20));
ts.add(new Student("lisi09", 19));
ts.add(new Student("lisi06", 18));
ts.add(new Student("lisi06", 18));
ts.add(new Student("lisi007", 29));
Iterator it = ts.iterator();
while(it.hasNext()) {
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class MyCompare implements Comparator {
public int compare(Object o1, Object o2) {
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num == 0) { // 当姓名的自然排序相同时,再判断一下年龄的自然排序
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); // 简写
// 以下这种方法很繁琐
/*
if(s1.getAge() > s2.getAge())
return 1;
if(s1.getAge() == s2.getAge())
return 0;
return -1;
*/
}
return num;
}
}
练习:按照字符串长度排序。
解:
字符串本身具备比较性,但是它的比较方式不是所需要的,这时就只能使用比较器。
import java.util.*;
class TreeSetTest {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new Comparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
java
----------
}
class StrLengthComparator implements Comparator {
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
// 以下这种方式繁琐
/*
if(s1.length() > s2.length())
return 1;
if(s1.length() == s2.length())
return 0;
return -1;
*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length())); // 简写
if(num == 0) // 当字符串长度相同时,再按照其自然顺序排序
return s1.compareTo(s2);
return num;
}
}