黑马程序员——JAVA集合
2015-06-14 13:17
405 查看
----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------
Vector、ArrayList、LinkedListList:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢。
|--ArrayList:内部是数组数据结构，是不同步的，替代了Vector。替代了Vector，查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
LinkedList方法:
addFirst();
addLast();
jdk1.6版本后新方法：
offerFirst();与addFirst方法没有区别。
offerLast();与addLast方法没有区别。
---------------------------------------------------------
getFirst();//获取但不移除，如果链表为空，抛出NoSuchElementException。
getLast();
jdk1.6版本后新方法：
peekFirst();//获取但不移除，如果链表为空，返回null。
peekLast();
--------------------------------------------------------
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException。
removeLast();
jdk1.6版本后新方法：
pollFirst();//获取并移除，如果链表为空，返回null;
pollLast();
示例1：
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class VectorDemo{
public static void main(String[] args){
Vector v = new Vector();
v.addElement( "abc1");
v.addElement( "abc2");
v.addElement( "abc3");
v.addElement( "abc4");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println( "nextElement:" + en.nextElement());
}
Iterator it = v.iterator();<
4000
br />
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
}
}
运行结果：
示例2：
import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListDemo{
public static void main(String[] args){
LinkedList link = new LinkedList();
link.addFirst( "abc1");
link.addFirst( "abc2");
link.addFirst( "abc3");
link.addFirst( "abc4");
Iterator it = link.iterator();
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
System.out.println(link);
System.out.println("getFirst:" + link.getFirst()); //获取第一个，但是不删除。
System.out.println("getLast:" + link.getLast());
System.out.println("removeFirst:" + link.removeFirst()); //获取第一个，但是删除
System.out.println("removeLast:" + link.removeLast());
//删除所有元素的方法
while(!link.isEmpty()){
System.out.println(link.removeFirst());
}
}
}
请使用LinkedList来模拟一个堆栈或者队列数据结构。
堆栈：先进后出 First In Last Out FILO
队列：先进先出 First In First Out FIFO
我们应该描述这样一个容器，给使用者提供一个容器对象完成这两种结构中的一种。
代码：
import java.util.LinkedList;
class DuiLie{
private LinkedList link;
public DuiLie(){
link = new LinkedList();
}
//队列的添加元素的功能。
public void myAdd(Object obj){
link.addLast(obj);
}
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
public class DuiLieTest{
public static void main(String[] args){
D
20dc8
uiLie dl = new DuiLie();
dl.myAdd( "abc1");
dl.myAdd( "abc2");
dl.myAdd( "abc3");
dl.myAdd( "abc4");
while(!dl.isNull()){
System.out.println(dl.myGet());
}
}
}
运行结果：
示例3：
import java.util.ArrayList;
import java.util.Iterator;
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
}
public class ArrayListTest{
public static void main(String[] args){
ArrayList al = new ArrayList();
al.add( new Person("lisi1" ,21));
al.add( new Person("lisi2" ,22));
al.add( new Person("lisi3" ,23));
al.add( new Person("lisi4" ,24));
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person)(it.next());
System.out.println(p.getName() + ":" + p.getAge());
}
}
}
运行结果：
Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet：内部数据结构是哈希表，是不同步的。
|--TreeSet：可以对Set集合中的元素进行排序，是不同步的。
示例4：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo{
public static void main(String[] args){
Set hs = new HashSet();
hs.add( "hahah");
hs.add( "heihei");
hs.add( "hehe");
hs.add( "xixi");
Iterator it = hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果：
哈希表确定元素是否相同
1. 判断的是两个元素的哈希值是否相同。
如果相同，再判断两个对象的内容是否相同。
2. 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。
P.S.
如果哈希值不同，不需要判断equals。
往HashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人，视为相同元素。
示例5：
import java.util.HashSet;
import java.util.Iterator;
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
public int hashCode(){
return name.hashCode() + age * 39;
}
public boolean equals(Object obj){
if(this == obj)
return true ;//同一个对象放两次，直接返回true
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
Person p = (Person)obj;
return this .name.equals(p.name) && this.age == p.age;
}
}
public class HashSetTest{
public static void main(String[] args){
HashSet hs = new HashSet();
hs.add( new Person("lisi4" ,24));
hs.add( new Person("lisi7" ,27));
hs.add( new Person("lisi1" ,21));
hs.add( new Person("lisi9" ,29));
hs.add( new Person("lisi7" ,27));
Iterator it = hs.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
}
运行结果：
定义功能去除ArrayList中的重复元素。
示例6：
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest{
public static void main(String[] args){
ArrayList al = new ArrayList();
al.add( new Person("lisi1" ,21));
al.add( new Person("lisi2" ,22));
al.add( new Person("lisi3" ,23));
al.add( new Person("lisi4" ,24));
al.add( new Person("lisi3" ,23));
al.add( new Person("lisi4" ,24));
System.out.println(al);
al = getSingleElement(al);
//remove底层用的还是equals方法
System.out.println(al.remove( new Person("lisi2" ,22)));
System.out.println(al);
}
public static ArrayList getSingleElement(ArrayList al){
//1、定义一个临时容器
ArrayList temp = new ArrayList();
//2、迭代al集合
Iterator it = al.iterator();
while(it.hasNext()){
Object obj = it.next();
//3、判断被迭代到的元素是否在临时容器存在
//contains方法依靠的是equals方法
if(!temp.contains(obj)){
temp.add(obj);
}
}
return temp;
}
}
运行结果：
无序变有序，使用LinkHashSet。
示例7：
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo{
public static void main(String[] args){
HashSet hs = new LinkedHashSet();
hs.add( "hahaa");
hs.add( "hehe");
hs.add( "heihei");
hs.add( "xixii");
Iterator it = hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果：
TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
示例8：
import java.util.Iterator;
import java.util.TreeSet;
class Person implements Comparable{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
public int hashCode(){
return name.hashCode() + age * 39;
}
public boolean equals(Object obj){
if(this == obj)
return true ;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
Person p = (Person)obj;
return this .name.equals(p.name) && this.age == p.age;
}
public int compareTo(Object o){
Person p = (Person)o;
//先按照年龄排序，再按照年龄排序，以免年龄相同的人，没有存进去。
int temp = this.age - p.age;
return temp == 0?this.name.compareTo(p.name):temp;
}
}
public class TreeSetDemo{
public static void main(String[] args){
TreeSet ts = new TreeSet();
//以Person对象年龄进行从小到大的排序
ts.add( new Person("zhangsan" ,28));
ts.add( new Person("wangwu" ,23));
ts.add( new Person("lisi" ,21));
ts.add( new Person("zhouqi" ,29));
ts.add( new Person("zhaoliu" ,25));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + ":" + p.getAge());
}
}
}
运行结果：
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素就需要实现Comparable接口，覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。
示例9：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
//创建了一个根据Person类的name进行排序的比较器。
class ComparatorByName implements Comparator{
public int compare(Object o1,Object o2){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
int temp = p1.getName().compareTo(p2.getName());
return temp == 0?p1.getAge()-p2.getAge() : temp;
}
}
public class TreeSetDemo{
public static void main(String[] args){
TreeSet ts = new TreeSet(new ComparatorByName());
//以Person对象年龄进行从小到大的排序
ts.add( new Person("zhangsan" ,28));
ts.add( new Person("wangwu" ,23));
ts.add( new Person("lisi" ,21));
ts.add( new Person("zhouqi" ,29));
ts.add( new Person("zhaoliu" ,25));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + ":" + p.getAge());
}
}
}
运行结果：
P.S.
如果自定义类实现了Comparable接口，并且TreeSet的构造函数中也传入了比较器，那么将以比较器的比较规则为准。
TreeSet集合的底层是二叉树进行排序的。
练习：对字符串进行长度排序。
代码：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest{
public static void main(String[] args){
TreeSet ts = new TreeSet(new ComparatorByLen());
ts.add( "aaaa");
ts.add( "zz");
ts.add( "nbag");
ts.add( "cba");
ts.add( "abc");
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class ComparatorByLen implements Comparator{
public int compare(Object o1,Object o2){
String s1 = (String)o1;
String s2 = (String)o2;
int temp = s1.length() - s2.length();
return temp == 0?s1.compareTo(s2):temp;
}
}
运行结果：
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员——JAVA集合
- 求职的途径
- 有深度，面试有用的题
- 程序员开心一下
- 九章算法面试题76 搜索二维矩阵
- 九章算法面试题75 二叉树的最小深度
- 九章算法面试题74 中位数
- 九章算法面试题73 翻转链表II
- 黑马程序员——Java语法基础（二）
- 面试时有哪些话是千万不能说的？
- 如何一周工作80-100小时还能拥有自己的生活?
- 黑马程序员——基础知识总结_static
- 作为一个程序开发者在职场中必须注意的7件事
- 黑马程序员------多线程创建的3种方式
- 黑马程序员---2015.6.13java基础笔记---构造代码块--this--static函数
- 黑马程序员—异常
- 请不要说自己是 Java 程序员
- 作为程序员必须要了解的位，字节，kb,mb,gb
- 总结过去10年的程序员生涯
- 黑马程序员---IO流-字符流