您的位置:首页 > 职场人生

黑马程序员——Java基础—集合

2015-06-02 15:48 555 查看
——- android培训java培训、期待与您交流! ———-

集合(Collection)是一个容器,长度可变,里面存储的是对象,可以存储不同类型的对象。它最常用的有单列集合Collection和双列集合Map两个接口的实现类。

Collection

  |–List

    |–ArrayList

    |–LinckedList

    |–Vector

  |–Set

    |–HashSet

    |–TreeSet

为什么有这么多的子类呢?

因为数据在计算机的存储方式是多样,所以需要定义不同的集合。由此可知,每个集合中的对象在计算机底层的存贮方式不一样,这个存储方式就是所谓的数据结构。

这些集合的数据结构分别是什么呢?

List和Set的区别:List集合元素是有序的,可以重复,每个元素都有索引;Set集合元素时无序的,不可以重复。

ArrayList:底层数据结构是数组结构,特征:查询快,增删慢,不同步JDK1.2出现的;

LinckedList:底层数据结构是链表数据结构,特征:查询慢,增删快;

Vector:底层数据结构是数据结构,特征:查询、增删都较慢,是同步的,JDK1.0出现。它有一个特有的方法:element()枚举法。

HashSet:底层数据结构是哈希表。HashSet是通过hashCode方法和equals方法来保证元素的唯一性的,所以在使用HashSet存储对象时,需要复写hashCode和equals方法。

TreeSet:底层数据结构是二叉树,可以对Set集合进行排序。排序方式有两种:一种是让对象自身具备排序功能,实现Comparable的接口,复写compareTo方法;第二种方法是让集合具有排序功能,定义一个类实现Comparator接口,复写compare方法,在新建集合时,就将该对象以参数的形式传递。注:排序时,当主要条件相同时,需要判断次要条件。

集合的基本操作

增加:boolean add(E e)

删除:

 A、boolean remove(Object o)

 B、void clear()//清空集合

获取:

 A、int size()//获取Collection的元素数

 B、Iterator iterator()//返回在此Collection的元素上进行迭代的迭代器。

判断:

 A、boolean contains(Object o)//如果此Collection包含指定元素,返回true;

 B、boolean isEmpty()//如果Collection集合为空,则返回true

高级for: for(数据类型 变量名 : 被遍历的对象)

     被遍历的对象:集合(Collection)或者数组,不可以修改只可以遍历,一定要有遍历对象。

集合的练习

ArrayList:

/*
ArrayList的练习:
将自定义对象作为元素存到ArrayList集合中,并去除重复元素。

比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。

思路:
1、对人描述,将数据封装进人对象。
2、定义容器,将人存入。
3、因为List集合是可以重复的,所以调用add的时候不会判断元素是否相同,
所以需要手动定义一个功能来判断元素是否相同。remove和contains方法
才会自动判断元素是否相同。
4、取出。

注:List集合判断元素是否相同,依据是元素的equals方法。

*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public String toString()
{
return name+";;"+age;
}
//Object中的equals方法是比较地址值,所以需要手动复写equals方法,而且不能用泛型
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
throw new ClassCastException("该类不是人类!");
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
}
class  ArrayListTest
{
public static void main(String[] args)
{
//定义ArrayList集合
ArrayList<Person> al = new ArrayList<Person>();
//想集合中存入对象
al.add(new Person("xiaozhang",20));
al.add(new Person("xiaoli",21));
al.add(new Person("xiaoxia",22));
al.add(new Person("xiaoxiao",23));
al.add(new Person("xiaoxue",24));
al.add(new Person("xiaozhang",20));

//去除相同元素
al = SingleElement(al);

//用迭代器将集合中的元素打印
Iterator<Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().toString());
}
}
//定义去除相同元素的方法
public static ArrayList<Person> SingleElement(ArrayList<Person> al)
{
ArrayList<Person> newAl = new ArrayList<Person>();
Iterator<Person> it = al.iterator();
while(it.hasNext())
{
//如果直接用next来代替,就会出现判断该元素,添加下一个元素
Person p = it.next();
if(!newAl.contains(p))
newAl.add(p);
}
return newAl;
}
}


LinkedList:

/*
使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈:先进后出  如同一个杯子。
队列:先进先出 First in First out  FIFO 如同一个水管。
LinkedList特有的方法:                     JDK1.6
void addFirst(E e)//在第一位添加元素       boolean offerFirst(E e)
void addLast(E e)//在末尾添加元素        boolean offerLast(E e)
E getFirt()//获取第一个元素                E peekFirst()
E getLast()//获取最后一个元素              E peekLast()
E removeFirst()//从开头处获取元素并移除    E pollFirst()
E removeLast()//从末尾处获取元素并移除     E pollLast()
*/
import java.util.*;
//定义一个类,将队列数据结构实现的功能封装进来
class DuiLie
{
private LinkedList<String> link;
DuiLie()
{
link = new LinkedList<String>();
}
public void myAdd(String obj)
{
link.add(obj);
}
public void getObject()
{
System.out.println(link.remove());
}
public boolean isEmpty()
{
return link.isEmpty();
}
}
//定义一类将堆栈数据结构实现的功能封装进来
class DuiZhan
{
private LinkedList<String> link ;
DuiZhan()
{
link = new LinkedList<String>();
}
public void myAdd(String obj)
{
link.add(obj);
}
public void getObject()
{
System.out.println(link.removeLast());
}
public boolean isEmpty()
{
return link.isEmpty();
}
}
class  LinkedListTest
{
public static void main(String[] args)
{
System.out.println("用linkedList模仿队列数据结构");
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");

while(!(dl.isEmpty()))
{
dl.getObject();
}
System.out.println("用linkedList模仿堆栈数据结构");
DuiZhan dz = new DuiZhan();
dz.myAdd("java01");
dz.myAdd("java02");
dz.myAdd("java03");
dz.myAdd("java04");

while(!(dz.isEmpty()))
{
dz.getObject();
}
}
}


HashSet:

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人,重复元素。

Set集合中不能有重复的元素,所以add方法在添加之前会判断元素是否已在集合中,
所以只需要复写判断元素是否相同的方法:hashCode和equals。

Set集合判断元素是否相同:先判断hashCode值,如果相同再通过equals判断是否是同一元素,
所以需要这两个的方法。
*/
import java.util.*;
class Student
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String toString()
{
return name+";;"+age;
}
//复写hashCode方法,为了减少调用equals的概率,最好将hashCode的值设置为判断元素是否
//相同的条件的值。age*27更能提高效率。
public int hashCode()
{
return name.hashCode()+age*27;
}
//复写equals方法,不能用泛型,因为在Object中就没用泛型
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("不是学生类,请重新输入!");
Student s = (Student)obj;
return this.name.equals(s.name) && this.age == s.age;
}
}
class HashSetTest
{
public static void main(String[] args)
{
//用泛型定义集合
HashSet<Student> hs = new HashSet<Student>();
//添加对象
hs.add(new Student("xiaozhang",20));
hs.add(new Student("xiaoli",19));
hs.add(new Student("xiaoyang",18));
hs.add(new Student("xiaoxiao",24));
hs.add(new Student("xiaozhang",20));

//用迭代器取出元素
Iterator<Student> it = hs.iterator();
while(it.hasNext())
{
System.out.println(it.next().toString());
}
}
}


TreeSet:可以对元素进行排序,不可重复

/*
将学生对象存储到TreeSet集合中,要求:学生对象有默认的排序方式,按照姓名排序。
现在要按照年龄来排序。
分析:定义一个学生类,并实现Comparable接口,复写compareTo方法(需要传入另一个学生对象),
因为此题不用默认的排序方式对集合排序,所以需要让集合具备排序功能,定义一个类,实现
Comparator接口,复写compare方法(需要传入两个学生对象)。

步骤:1、定义学生类;
2、定义一个比较器;
3、建立集合,并向其存放学生对象;
4、取出学生对象。

注:两种排序方式并存,以比较器为主。排序的时,如果主要条件一样,需要判断次要条件,
排序的同时,也保证了元素的唯一性。

其他说明:String、Integer类中,已复写了eqauls、hashCode、compareTo方法,
所以直接拿来使用就可以了。
*/
import java.util.*;
//定义学生类
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String toString()
{
return name+"::"+age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写compareTo方法
public int compareTo(Student s)
{
int num = this.name.compareTo(s.name);
if(num == 0)
return new Integer(this.age).compareTo(new Integer(s.age));
return num;
}
}
//定义比较器,并以参数的形式传递给TreeSet的构造函数
class MyCompare implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
if(num == 0)
return s1.getName().compareTo(s2.getName());
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
//定义集合
TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
//向集合中存储学生对象
ts.add(new Student("zhangsan",20));
ts.add(new Student("lisi",21));
ts.add(new Student("xiaoli",23));
ts.add(new Student("小斯",24));
ts.add(new Student("lisi",21));

//因为只是取出元素,不修改,所以用高级far
for(Student s : ts)
{
System.out.println(s.toString());
}
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: