黑马程序员—java基础_集合List和Set

-------
android培训、java培训、期待与您交流！ ----------

1.List特有方法：凡是可以操作角标的方法都是该体系的特有方法

增：add（index，elements）；addAll（index，Collection）

删：remove（index）

改：set（index，elements）

查：get（index）；subList（from，to）；listIterator（）；int indexOf（obj）

List集合特有的迭代器：ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，所以在迭代器时，只能用迭代器的方法操作元素，Iterator方法是有限的，只能对元素进行判断、取出和删除操作。

如果想要其他的操作如添加，修改等，需要使用其子接口：ListIterator，该接口只能通过List集合的ListIterator方法获取。

2.LinkList特有方法：

addFirst（）；addLast（）

getFirst（）；getLast（）：获取元素，不删除元素，元素不存在出现NoSuchElementException

removeFirst（）；removeLast（）：获取元素，并删除元素，元素不存在出现NoSuchElementException

JDK1.6版本后出现替代方法：

offerFirst（）；offerLast（）

peekFirst（）；peekLast（）获取元素，不删除元素,如果集合没有元素，会返回null

pollFirst（）；pollLast（）获取元素，并删除元素，如果集合没有元素，会返回null

3.ArrayList练习：去除ArrayList集合中的重复元素

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {

/**
* 去除ArrayList集合中的重复元素。
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> al=new ArrayList<String>();
al.add("java01");
al.add("java03");
al.add("java02");
al.add("java02");
al.add("java03");
al.add("java01");

al=singleElement(al);//调用方法
//使用迭代器打印去除重复元素后的集合

for(Iterator<String> it=al.iterator();it.hasNext();)
System.out.println(it.next());

}
//定义功能去除集合中的重复元素
public static ArrayList<String> singleElement(ArrayList<String> al)
{
ArrayList<String> newAl=new ArrayList<String>();//定义临时集合存储去除后的集合
//使用迭代器
Iterator<String> it=al.iterator();
while (it.hasNext())
{
String str=it.next();
if(!newAl.contains(str))//判断newA1集合里面的元素是否存在，若不存在就添加
newAl.add(str);
}
return newAl;
}

}

4.LinkList练习：模拟队列的数据结构

import java.util.*;
public class LinkListTest {

/**
* 使用LinkedList模拟一个队列数据结构。
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
DuiLie dl=new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
dl.myAdd("java05");

while(!dl.isNull())
System.out.println(dl.myGet());

}

}
//定义一个类实现队列的数据结构：先进先出
class DuiLie{
private LinkedList link;//新建一个LinkList集合
DuiLie(){
link=new LinkedList();//构造函数一初始化就有一个LinkList集合
}
public void myAdd(Object obj)
{
link.addLast(obj);//添加对象，依次在对象后面添加
}
public Object myGet()
{
return link.removeFirst();//队列先进，先取出
}
public boolean isNull()
{
return link.isEmpty();//判断link的对象是否为空
}
}

5.HashSet练习：往HashSet集合存入自定义对象，姓名和年龄相同为同一人，重复元素。

class HashSetTest
{

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));

Iterator it = hs.iterator();

while(it.hasNext())
{
Person p = (Person)it.next();//强转，需要用到Person类的方法
System.out.println(p.getName()+"::"+p.getAge());
}
}
}

//新建人类
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}

public int hashCode()//复写hashCode方法，HashSet集合判断唯一性是根据hashCode方法
{
System.out.println(this.name+"....hashCode");
return name.hashCode()+age*37;//判断姓名字符串的hashCode是否相同
}

public boolean equals(Object obj)//若hashCode方法判断相同，再调用equals方法判断
{

if(!(obj instanceof Person))//判断是否为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;//姓名和年龄想同才为重复元素
}

public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

6.TreeSet：

可以对Set集合中的元素进行排序，底层数据是二叉树，保证元素唯一性的依据：compareTo方法 return 0。

TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法，即元素的自然顺序

TreeSet的第二种排序方式：当元素自身不具备比较时，或者具备的比较性不是所需的。这时需要让集合自身具备比较性，可以定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。定义一个类，实现Comparator接口，覆盖compare方法

练习1：在TreeSet集合中存储自定义对象学生。按照学生的年龄进行比较

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));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi01",40));

Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();//强转
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}

class Student implements Comparable//该接口强制让学生具备比较性，实现Comparable接口
{
private String name;
private int age;

Student(String name,int age)
{
this.name = name;
this.age = age;
}

public int compareTo(Object obj)//覆盖compareTo方法
{

if(!(obj instanceof Student))//判断是否为学生类
throw new RuntimeException("不是学生对象");//抛出RuntimeException异常，函数不用声明
Student s = (Student)obj;

if(this.age>s.age)
return 1;
if(this.age==s.age)//年龄相同要定义次要方法
{
return this.name.compareTo(s.name);//字符串类的compareTo比较姓名是否相同。
}
return -1;
}

public String getName()
{
return name;

}
public int getAge()
{
return age;
}
}

练习2：按照字符串长度排序，使用比较器

import java.util.*;
class  TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());//传入自定义的比较器

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());
}
}
}

class StrLenComparator implements Comparator//自定义比较器实现Comparator接口
{
public int compare(Object o1,Object o2)//覆盖compare方法
{
String s1 = (String)o1;
String s2 = (String)o2;

int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));//字符串长度进行比较
if(num==0)
return s1.compareTo(s2);//次要比较按照字符串自然顺序进行比较

return num;
}
}

7.泛型：JDK1.5版本以后出现新特性，用于解决安全问题。

好处：1.将运行时期出现的问题ClassCastException转移到编译时期。2.避免强制转换的麻烦

格式：通过<>来定义要操作的引用数据类型，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中，

ArrayList<String> al = new ArrayList<String>();

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定那么可以将泛型定义在方法上。？ extends E: 可以接收E类型或者E的子类型。上限。？ super E: 可以接收E类型或者E的父类型。下限

class Demo<T>；public <Q> void print(Q q)