List集合

容器：存储数据

基本功能：增删改查

增加:booleanadd(E e) 将指定的元素追加到此列表的末尾(可选操作)。

id add(intindex, E element) 将指定的元素插入此列表中的指定位置(可选操作)。boolean addAll(Collection extends E>c) 按指定集合的迭代器(可选操作)返回的顺序将指定集合中的所有元素附加到此列表的末尾。boolean addAll(int index, Collection extends E>c) 将指定集合中的所有元素插入到此列表中的指定位置(可选操作)。

删除:voidclear() 从此列表中删除所有元素(可选操作)。void remove(intindex) 删除该列表中指定位置的元素(可选操作)。booleanremove(Object o) 从列表中删除指定元素的第一个出现(如果存在)(可选操作)boolean removeAll(Collection>c) 从此列表中删除包含在指定集合中的所有元素(可选操作)。

修改:

E set(intindex, E element) 用指定的元素(可选操作)替换此列表中指定位置的元素。

查询:

E get(intindex) 返回此列表中指定位置的元素。

Iteratoriterator() 以正确的顺序返回该列表中的元素的迭代器。

Iterator迭代器对象

hasNext():可以通过它判断 集合里面是否还有下一个元素

next():获取下一个元素

ListIteratorlistIterator() 返回列表中的列表迭代器(按适当的顺序)。

正向迭代:

ListIterator lit=list.listIterator();while(lit.hasNext()){

System.out.println(lit.next());

}

反向迭代:while(lit.hasPrevious()){

System.out.println(lit.previous());

}

注意:使用反向迭代，先要正向迭代一次。

ListIterator listIterator(intindex) 从列表中的指定位置开始，返回列表中的元素(按正确顺序)的列表迭代器。

判断:boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。

常用子类:

ArrayList：底层是数组结构，默认长度是10，当我们存储的数据超过了10个之后，它会自动的增加原来的一半也是自动增加5个长度

LinkedList:底层是链表结构，无下标排序。

例子: 模拟堆栈和队列的特点

堆栈：先进后出 (如同水杯)

队列：先进先出 (如同水管)

Vector ：底层是数组结构，默认长度是10，超过默认长度自增10个。它和list相比是线程安全。这个是jdk1.2就有的原始元素，以及被ArrayList淘汰

代码实例

packagecom.ly.listapi;importjava.util.ArrayList;importjava.util.Iterator;importjava.util.List;importjava.util.ListIterator;/*** 使用ArrayList测试List的api*/

public classListApi {public static voidmain(String[] args) {//创建一个集合

List list =newArrayList();

List list2=newArrayList();

String str="hi update";

list2.add(1);

list2.add(2);//添加元素

list.add("张三");

list.add(true);

list.add(10);

list.add(0.001f);

list.add("1234444");//制定的下标添加

list.add(2,"hi");//在制定的下标插入一个集合

list.addAll(3,list2);//System.out.println(list2.size());//删除集合中所有的元素

/*list2.clear();*/

//System.out.println(list2.size());

System.out.println("----------------------");

list.remove(0);

list.remove(true);

list.removeAll(list2);//修改元素

list.set(0,"hi update");//包含//System.out.println(list.contains(str));

/*** 遍历集合 (4种)*/

/*for(int i=0;i

System.out.println(list.get(i));

}*/

/*for(Object obj:list){

System.out.println(obj);

}*/

/***

* 集合特有的迭代方式 迭代器*/

/*Iterator it =list.iterator();

while(it.hasNext()){

System.out.println(it.next());

}*/

/***

* 正向迭代*/ListIterator lit=list.listIterator();while(lit.hasNext()){

System.out.println(lit.next());

}/**/

/***

* 反向迭代*/

/*ListIterator lit =list.listIterator();*/

while(lit.hasPrevious()){

System.out.println(lit.previous());

}//System.out.println(list.size());

}

}

packagecom.ly.linkedListDemo;importjava.util.LinkedList;importjava.util.List;/***

* 使用linkedList 完成堆栈和队列的效果

* removeFirst()

从此列表中删除并返回第一个元素。

removeLast()

从此列表中删除并返回最后一个元素。*/

public classLinkedListDemo {public static voidmain(String[] args) {

LinkedList list=newLinkedList();

list.add(111);

list.add("222");

list.add(true);/*while(!list.isEmpty()){

System.out.println(list.removeLast());

}*/

while(!list.isEmpty()){

System.out.println(list.removeFirst());

}

}

}

ArrayList去重(其类一致的时候会将值进行比较【个人理解，里面存储的数据类型不一样，例如Person类，遇上相同的数据类型会调用本类(例如同样是Person就调用Person)中的equals方法，但像Person这样不具备比较性的则要继承Comparable类来实现重写equal方法】

依据equal方法(正常情况是使用hash值)，则此时我们需要重写equal方法

public classArrayListDemo {public static voidmain(String[] args) {

ArrayList list=newArrayList();

Person p=newPerson();

p.setAge(19);

p.setUsername("aaaa");

p.setPassword("aaaa");

list.add(p);

Person p1=newPerson();

p1.setAge(19);

p1.setUsername("aaa1");

p1.setPassword("aaaa");

list.add(p1);

ArrayList newList=replaceList(list);for(int i=0;i

Person pi=(Person)newList.get(i);

System.out.println(pi.getUsername());

}

}

private staticArrayList replaceList(ArrayList list) {

ArrayList newlist=newArrayList();

Iterator it=list.iterator();while(it.hasNext()){

Object obj=it.next();if(!newlist.contains(obj)){

newlist.add(obj);

}

}returnnewlist;

}

}

packagecom.ly.po;/***

* 用户对象*/

public class Person implementsComparable{privateString username;privateString password;private intage;publicString getUsername() {returnusername;

}public voidsetUsername(String username) {this.username =username;

}publicString getPassword() {returnpassword;

}public voidsetPassword(String password) {this.password =password;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}

@Overridepublic inthashCode() {return 0;

}publicPerson() {

}public Person(String username, String password, intage) {this.username =username;this.password =password;this.age =age;

}

@Overridepublic booleanequals(Object obj) {if(obj instanceofPerson){return this.username.equals(((Person) obj).getUsername()) && this.age==((Person) obj).getAge() && this.password.equals(((Person) obj).getPassword());

}else{return false;

}

}//p.compareTo(p1){}

@Overridepublic intcompareTo(Object o) {if(o instanceofPerson){

Person p=(Person) o;return (this.getUsername().hashCode()-p.getUsername().hashCode()) -(this.age-p.age) -(this.getPassword().hashCode()-p.getPassword().hashCode());

}return -1;

}

}

这个的思路是：新建一个集合，迭代list，建立一个Object对象，使其通过if(！newlist.contains(obj))方法来实现判断【这里contains()方法会引用equals方法(所以需要重写equals方法)，此时会将集合里的数据调用equal方法去比较obj】如果不包含则add()加入，包含则不添加

List有序，元素可重复，集合有索引  ||  Set无序，元素不可重复，集合无索引

Set的共性方法与List差不多

1.HashSet底层是哈希表(由哈希值(有16位进制组成的数)组成的表)，在Java中每个元素都有一个HashCode方法，方法返回所在的物理内存地址(一般情况下每个数的hash值不同)

(输出对象(例如Person p)输出p(如果没有toString方法，则输出物理内存地))

HashSet无顺序，不允许重复

HashSet存自定义对象去重思路：比较重复是根据hashcode值来比较，如果一样就使用equal方法再进行比较，但一般情况下hashcode的值是不相同的，所以要在自定义对象中重写hashcode方法使hashcode的值相等【public int hashcode( return 50;)】

packagecom.ly.com.ly.setdemo;importcom.ly.po.Person;importjava.util.HashSet;importjava.util.Iterator;/***

* 测试hashset*/

public classHashSetDemo {public static voidmain(String[] args) {

HashSet set=newHashSet();

set.add("java 01");

set.add("java 02");

set.add("java 03");

set.add("java 04");

set.add("java 01");

set.add("java 03");

Iterator it=set.iterator();while(it.hasNext()){

System.out.println(it.next());

}

Person p=newPerson();

p.setUsername("zhangsan");

p.setPassword("123456");

p.setAge(19);

Person p2=newPerson();

p2.setUsername("zhangsan");

p2.setPassword("123456");

p2.setAge(19);

HashSet pset=newHashSet();

pset.add(p);

pset.add(p2);

Iterator it1=pset.iterator();while(it1.hasNext()){

System.out.println(it1.next());

}

}

}

TreeSet 有序无下标，以二叉树来比较，底层是二分叉树，有自己的排序规则，存放元素必须具备比较性(八大元素和String都实现了Comparable)

要是自定义对象具备比较性，实现Comparable接口，实现comparableTo方法来进行比较【public int comparableTo(Object o){。。。}】

packagecom.ly.com.ly.treesetdemo;importcom.ly.com.ly.comable.MyComparator;importcom.ly.po.Person;importjava.util.Iterator;importjava.util.TreeSet;public classTreeSetDemo {public static voidmain(String[] args) {/*TreeSet tset =new TreeSet();*/

//tset.add(true);//tset.add(false);//tset.add("java 03");//tset.add("java 04");//tset.add("java 01");//Iterator it =tset.iterator();//while(it.hasNext()){//System.out.println(it.next());//}

TreeSet tset =new TreeSet(newMyComparator());

Person p=new Person("211","1111",22);

Person p1=new Person("222","2222",30);

Person p2=new Person("123","2222",30);

tset.add(p);

tset.add(p1);//p和p1已经比较完了 p p1 p1 p

tset.add(p2);

Iterator it=tset.iterator();while(it.hasNext()){

Person obj=(Person)it.next();

System.out.println(obj.getUsername());

}

}

}

packagecom.ly.com.ly.comable;importcom.ly.po.Person;importjava.util.Comparator;public class MyComparator implementsComparator{

@Overridepublic intcompare(Object o1, Object o2) {if(o1 instanceof Person && o2 instanceofPerson){return (((Person) o1).getUsername().hashCode()+((Person) o1).getPassword().hashCode()+((Person) o1).getAge())-(((Person) o2).getUsername().hashCode()+((Person) o2).getPassword().hashCode()+((Person) o2).getAge());

}return 0;

}

/**

* 实现Comparable 接口

* 然后实现compareTo方法

* @param o

* @return

*/

public int compareTo(Object o) {

if (o instanceof User) {

User user = (User) o;

//比较两个对象的age 返回的是它们的减法值，如果this.age>user.age返回正数，反之返回负数，相等返回0

return this.age-user.age;

//            System.out.println("this:"+(this.name.hashCode()+this.age));

//            System.out.println("user:"+(user.name.hashCode()+user.age));

//            System.out.println("compare:"+((this.name.hashCode()+this.age)-(user.name.hashCode()+user.age)));

//            return (this.name.hashCode()+this.age)-(user.name.hashCode()+user.age);

}else{

throw new RuntimeException("不是用户类");

}

}

}，

思路：TreeSet在add()对象时会自动将对象排序，但需要有可比较性，如自定义类就需要实现comparable类，实现comparableTo方法才可以进行比较

TreeSet可以自传比较器(其本身自带二叉树比较)

除了上面那种实现接口比较以外，还有一种比较方式：/*** 新建一个比较器对象

*@authorAdministrator

**/

public class MyCompare implementsComparator{/*** 编写具体的比较规则*/

public intcompare(Object o1, Object o2) {if(o1 instanceof User && o2 instanceofUser){

User user1=(User)o1;

User user2=(User)o2;return user1.getAge()-user2.getAge();

}else{throw new RuntimeException("要比较的类型不一致无法比较");

}

}

}public static voidmain(String[] args) {

TreeSet set1=new TreeSet(newMyCompare());

set1.add(new User("java01",11));

set1.add(new User("java02",12));

set1.add(new User("java01",11));

set1.add(new User("java03",13));

Iterator it1=set1.iterator();while(it1.hasNext()){

System.out.println(it1.next());

}

当自定义(就是自己重写的equals方法)和比较器(自己写的)都存在时，以比较器为主

HashSet和TreeSet的区别

HashSet        底层是哈希表，没有顺序，不允许重复

TreeSet       底层是二叉树结构，有顺序 ，不允许重复

但它们都是存储数据的容器

泛型  由于集合数据类型不同，迭代大多需要强行转型(由大转小可能导致数据丢失)，所以泛型应此而生了

泛型：因为集合可以存储任意对象的元素，所以在开发过程中无法保证集合内元素的一致性，在早期的遍历过程中，

需要我们不断的去把Object 转换成我们所需要的对象的类型，来过滤掉其他数据类型，遍历出来。时间长了程序员就觉得这样很麻烦，

于是就有了泛型。泛型提供了更好的解决方案：类型参数。例如，ArrayList类用一个类型参数来指出元素的类型。

泛型是Java1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

Java泛型被引入的好处是安全简单。

在Java SE1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，

而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

作用：

1.申明准确类型(申明定义准确类型，集合只能插入准确的类型)

packagecom.ly.com.ly.genericity;importcom.ly.po.Person;importjava.util.ArrayList;/***

* 通过ArrayList 来说明泛型的作用

* 1.申明准确的类型

* 声明的时候就顶了准确的类型,以后集合里面只能插入定义的类型*/

public classArrayListDemo {public static voidmain(String[] args) {

ArrayList plist=new ArrayList<>();

plist.add(new Person("aaa","aaaa",18));for(Person p:plist){

System.out.println(p.getUsername()+"\t"+p.getPassword()+"\t"+p.getAge());

}

}

}

2.定义了抽象类型(一般用来编写扩展性强的类或者是工具类)

packagecom.ly.com.ly.dao;importcom.ly.po.stu;//T 或者E 你就可以看成是Object

public class BaseDao{privateT t;public voidadd(T t){

System.out.println(t+"添加");

}public voidupdate(T t){

System.out.println(t+"修改");

}public voidfind(T t){

System.out.println(t+"查询");

}public voiddelete(T t){

System.out.println(t+"删除");

}

}

然后接下来顺便将例子放出

packagecom.ly.com.ly.test;importcom.ly.com.ly.dao.StuDao;importcom.ly.com.ly.dao.teacherDao;importcom.ly.po.stu;importcom.ly.po.teacher;public classdemo {public static voidmain(String[] args) {

teacher t=new teacher("t1","男",1000);

teacherDao tdao=newteacherDao();

tdao.add(t);

tdao.update(t);/*tdao.addtea(t);

tdao.updatetea(t);

tdao.findtea(t);

tdao.deletetea(t);*/stu s=new stu("aaa","男","软件1班");

StuDao dao=newStuDao();

dao.add(s);/*dao.addStu(s);

dao.updatestu(s);

dao.findstu(s);

dao.deletestu(s);*/}

}

packagecom.ly.com.ly.dao;importcom.ly.po.stu;importorg.junit.Test;/***

* 模拟完成stu的增删改查方法

**/

public class StuDao extendsBaseDao{/*public void addStu(stu stu){

System.out.println(stu+"添加");

}

public void updatestu(stu stu){

System.out.println(stu+"修改");

}

public void deletestu(stu stu){

System.out.println(stu+"删除");

}

public void findstu(stu stu){

System.out.println(stu+"查询");

}*/}

packagecom.ly.com.ly.dao;importcom.ly.po.stu;importcom.ly.po.teacher;public class teacherDao extendsBaseDao{/*public void addtea(teacher tea){

System.out.println(tea+"添加");

}

public void updatetea(teacher tea){

System.out.println(tea+"修改");

}

public void deletetea(teacher tea){

System.out.println(tea+"删除");

}

public void findtea(teacher tea){

System.out.println(tea+"查询");

}*/}

Map集合

java中的map集合使用键(key)值(value)来保存数据，其中值(value)可以重复，但键(key)必须是唯一，也可以为空，但最多只能有一个key为空，

它的主要实现类有HashMap、LinkedHashMap、TreeMap。

共性方法：1.添加：

put();

putAll();2.删除

clear();清空数据

remove();通过Key删除单个值，还可以放集合删除3.判断

containsKey(Object key);

containsValue(Object value);

isEmpty();4.获取

get();

size();

values();

entrySet();

keySet();

map的遍历：

Map map=new HashMap();

map.put("01", "java 01");

map.put("02", "java 02");

map.put("03", "java 03");

map.put("04", "java 04");

map.put("05", "java 05");/*** 遍历方式1*/

//获取到map中key值的集合

Set keys=map.keySet();//遍历其中的key值的集合

Iterator it=keys.iterator();//根据key获取到value

while(it.hasNext()){

String key=it.next();

String value=map.get(key);

System.out.println("key:"+key+" value:"+value);

}/*** 遍历方式2*/

//获取到map的关系映射放到set集合中

Set> sets =map.entrySet();//迭代集合

Iterator> it2=sets.iterator();while(it2.hasNext()){//获取到集合中的每个映射关系

Map.Entry map2 =it2.next();//获取key和value

System.out.println("key:"+map2.getKey()+" value:"+map2.getValue());

}

packagecom.ly.mapdemo;importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;/***

* 学习map的数据类型

* mapapi:

* V put(K key, V value)

将指定的值与该映射中的指定键相关联(可选操作)*/

public classHashMapDemo {public static voidmain(String[] args) {

HashMap map=newHashMap();

HashMap map1=newHashMap();

map1.put(null,"ssss");

map1.put("lll",1111);/***

* map添加 key，value

* k,v*/map.put("aaa",1111);

map.put("cccc",222);

map.put("aaa",2222);

map.putAll(map1);

System.out.println(map.containsKey("sskl;sks;lsk"));

System.out.println(map.containsValue("1111"));

System.out.println(map.get(null));//map1.clear();

map1.remove(null);

System.out.println(map1.size());/***

* map的数据结构比较特殊，它是存一组数据，那如果来区分存进去的每组数据和每组数据列，它是通过列名来区分

* 所以说key 的值不允许出现重复的，或者会覆盖原先的数据。*/System.out.println(map.size());/***

* map遍历方式1*/

/*Set keySet=map.keySet();

Iterator it =keySet.iterator();

while(it.hasNext()){

System.out.println(map.get(it.next()));

}*/

/***

* 第二种遍历方式*/Set> set =map.entrySet();

Iterator> it =set.iterator();while(it.hasNext()){

Map.Entry obj=it.next();

System.out.println(obj.getKey()+":"+obj.getValue());

}

}

}

思路：上面entryset()看成是一个Set对象，Map集合名.Entry是将集合看成由一个个Key和Value组成的对象

Hashtable:底层是哈希表的数据结构，不可以存入null键和null值，是线程同步的。jdk1.0效率低

HashMap：底层也是哈希表数据结构，允许存入null键null值，线程不同步。(这 HashMap类大致相当于 Hashtable，除了它是不同步的，允许空值。)jdk2.0效率高

TreeMap：底层是二叉树结构，线程不同步，可以给map集合中的key 进行排序。

总结：通过这三个具体类的描述，我们发现它和set集合是不是很像，其实set集合底层调用的都是map集合的方法。

例子

我们用user对象来作为key,判断如果年龄和姓名一样的user对象在map中只能有一个key存一个值。public class User implementsComparable{privateString name;private intage;publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}public User(String name, intage) {super();this.name =name;this.age =age;

}publicString toString() {return "User [name=" + name + ", age=" + age + "]";

}/*** 重写hashCode方法

**/

public inthashCode() {//TODO Auto-generated method stub

return (name.hashCode()+age)*100;

}/*** 重写 equals方法*/

public booleanequals(Object obj) {if(obj instanceofUser){

User u=(User)obj;return this.name.equals(u.name) && this.age==u.age;

}else{return false;

}

}/*** 重写比较性的方法*/

public intcompareTo(Object o) {if(o instanceofUser){

User u=(User)o;int num=this.age-u.age;if(num==0){return this.name.compareTo(u.name);

}returnnum;

}else{throw new RuntimeException("传错了");

}

}

}public classTest {public static voidmain(String[] args) {//Map map =new HashMap();

Map map=new TreeMap();

map.put(new User("张三",18), "北京");

map.put(new User("张三",18), "北京");

map.put(new User("王武",18), "北京");

map.put(new User("王武",18), "上海");

map.put(new User("赵六",19), "武汉");/*** 迭代*/Set keys=map.keySet();

Iterator it=keys.iterator();while(it.hasNext()){

User user=it.next();

String value=map.get(user);

System.out.println("key:"+user+" value:"+value);

}

}

}