java list 不可重复_Java-List(有序，可重复,有索引)，HashSet(无序，不可重复)，TreeSet(有序，不可重复)，Map(具有映射关系)：HashMap与TreeMap(与...

1.概念

java集合存放于包java.util包中，是一个用来存放对象的容器

只能存放对象，例如：存放int是转换成Integer对象

集合存放的是多个对象的引用，对象本身还是放在堆内存中

集合可以存放不同类型，不限数量的数据类型

2 HashSet(无序，不可重复)

HashSet是set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSet集合

HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找功能

Hash具有以下特点：不能保证元素的排列顺序，不可重复，HashSet不是线程安全的，集合元素可以使null

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashcode值，然后根据hashCode值决定该对象在HashSet中的存储位置

如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功

2.1 代码如下：

package demo;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class Test2 {

public static void main(String[] args) {

Set set=new HashSet();

//Set set=new HashSet();//与上面的等价

set.add(1);

set.add("a");//添加对象到集合

System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, a]

set.remove(1);//移除对象

System.out.println("移除对象:"+set);//移除对象:[a]

System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false

System.out.println("判断是否包含元素a:"+set.contains("a"));//判断是否包含元素a:true

set.clear();//清空集合

System.out.println("清空集合:"+set);//清空集合:[]

set.add("a");

set.add("b");

set.add("c");

set.add("d");

//set集合存的值是不重复的

set.add(1);

set.add(true);

set.add(null);

System.out.println(set);//[null, a, 1, b, c, d, true]

//迭代器遍历集合

System.out.println("迭代器遍历集合");

Iterator it=set.iterator();

while(it.hasNext()) {

System.out.print(it.next()+" ");//null a 1 b c d true

}

//for Each迭代集合

System.out.println();

System.out.println("for Each迭代集合");

for(Object obj:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值

System.out.print(obj+" ");//null a 1 b c d true

}

System.out.println();

System.out.println(set.size());//获取集合的元素个数:7

//如果想要让集合只能存同样类型的对象，怎么做

//使用泛型

Set set1=new HashSet();//比如指定String为集合的泛型，那么这个集合不能存String类型之外的数据

set1.add("abc");

//set1.add(1);这样是不行的

}

}

3.TreeSet(有序，不可重复)

TreeSet可以确保集合元素处于排序状态，TreeSet支持两种排序方法：自然排序和定制排序

3.1 代码如下

package demo;

import java.util.Comparator;

import java.util.Iterator;

import java.util.Set;

import java.util.TreeSet;

public class Test3 {

public static void main(String[] args) {

// TODO 自动生成的方法存根

Set set=new TreeSet();//TreeSet的自然排序

set.add(5);

set.add(2);

set.add(4);

set.add(3);

set.add(1);

System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, 2, 3, 4, 5]

set.remove(1);//移除对象

System.out.println("移除对象:"+set);//移除对象:[2, 3, 4, 5]

System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false

//迭代器遍历集合

System.out.println("迭代器遍历集合");

Iterator it=set.iterator();

while(it.hasNext()) {

System.out.print(it.next()+" ");//2 3 4 5

}

//for Each迭代集合

System.out.println();

System.out.println("for Each迭代集合");

for(Integer i:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值

System.out.print(i+" ");//2 3 4 5

}

System.out.println();

System.out.println(set.size());//获取集合的元素个数:4

set.clear();//清空集合

System.out.println("清空集合:"+set);//清空集合:[]

Person p1=new Person("zhangsan",17);

Person p2=new Person("lisi",23);

Person p3=new Person("wangwu",20);

Person p4=new Person("zhaoliu",29);

Set set1=new TreeSet(new Person());//TreeSet的定制排序

set1.add(p2);

set1.add(p4);

set1.add(p3);

set1.add(p1);

System.out.println("for Each迭代集合");

for(Person p:set1) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值

System.out.println(p.name+" "+p.age+" ");//zhangsan 17 wangwu 20 lisi 23 zhaoliu 29

}

}

}

//TreeSet定制排序，需要实现Comparator接口

class Person implements Comparator{ //把Person对象存到TreeSet中并按照年龄排序

int age;

String name;

public Person() {

}

public Person(String name,int age) {

this.name=name;

this.age=age;

}

@Override

public int compare(Person arg0, Person arg1) {

// TODO 自动生成的方法存根

if(arg0.age>arg1.age) {

return 1;

}else if(arg0.age

return -1;

}else {

return 1;

}

}

}

4.List(有序，可重复,有索引)

默认按元素的添加顺序设置索引

4.1 ArrayList

package demo;

import java.util.ArrayList;

public class List {

public static void main(String[] args) {

// TODO 自动生成的方法存根

ArrayList list=new ArrayList();

list.add("b");//第一个，索引下标0

list.add("d");//第二个，索引下标1

list.add("a");//允许使用重复元素

list.add("e");

list.add("c");

list.add("a");

System.out.println("按默认方式存入数据"+list);//按默认方式存入数据[b, d, a, e, c, a]

System.out.println(list.get(2));//通过索引来访问指定位置的集合元素:a

list.add(1,"f");

System.out.println("在指定下标的位置插入数据"+list);//在指定下标的位置插入数据[b, f, d, a, e, c, a]

ArrayList list1=new ArrayList();

list1.add("123");

list1.add("456");

list.addAll(2, list1);//在指定元素位置插入集合

System.out.println("按在指定元素位置存入集合数据"+list);//按在指定元素位置存入集合数据[b, f, 123, 456, d, a, e, c, a]

System.out.println(list.indexOf("a"));//获取指定元素在集合第一次出现的索引下标:5

System.out.println(list.lastIndexOf("a"));//获取指定元素在集合最后一次出现的索引下标:8

list.remove(2);//根据指定索引下标移除元素

System.out.println("移除对象:"+list);//移除对象:[b, f, 456, d, a, e, c, a]

list.set(1,"ff");//修改指定下标的值

System.out.println("修改指定下标之后的集合"+list);//修改指定下标之后的集合[b, ff, 456, d, a, e, c, a]

@SuppressWarnings("unused")

//根据索引的起始位置来截取一段元素形成一个新集合，元素的索引截取时包含开始，不包含结尾

java.util.List sublist=list.subList(2, 4);

System.out.println("截取的数组:"+sublist);//截取的数组:[456, d]

System.out.println(list.size());//获取集合的元素个数:8

}

}

5.Map(具有映射关系)

Map有两组值，一个是key，一个是value，类型不限，key不允许有重复值，key与value存在单向1对1关系

5.1 HashMap与TreeMap

package demo;

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

import java.util.TreeMap;

public class Map {

public static void main(String[] args) {

//前面试接口，后面是实现类

//Map map=new HashMap;

HashMap map=new HashMap();

map.put("b",1);

map.put("c",2);

map.put("a",2);

System.out.println("按默认方式存入数据："+map);//按默认方式存入数据：{a=2, b=1, c=2}

System.out.println("根据key取值："+map.get("b"));//根据key取值：1

map.remove("c");

System.out.println("根据key移除键值对:"+map);//根据key移除键值对:{a=2, b=1}

System.out.println("获取集合的元素个数:"+map.size());//获取集合的元素个数:2

System.out.println("判断当前的集合是否存在指定的key:"+map.containsKey("b"));//判断当前的集合是否存在指定的key:true

System.out.println("判断当前的集合是否存在指定的value:"+map.containsValue(1));//判断当前的集合是否存在指定的value:true

System.out.println("获取map集合的key的集合："+map.keySet());//获取map集合的key的集合：[a, b]

System.out.println("获取map集合的所有value值："+map.values());//获取map集合的所有value值：[2, 1]

Set keys=map.keySet();

//for Each迭代集合,通过map.keySet()遍历map集合

System.out.println();

System.out.println("for Each迭代集合,通过map.keySet()遍历map集合");

for(String key:keys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值

System.out.println("key:"+key+",value:"+map.get(key));key:a,value:2 key:b,value:1

}

//for Each迭代集合,通过map.entrySet()遍历map集合

Set> entrys=map.entrySet();

System.out.println();

System.out.println("for Each迭代集合,通过map.entrySet()遍历map集合");

for(Entry en:entrys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值

System.out.println("key:"+en.getKey()+",value:"+en.getValue());//key:a,value:2 key:b,value:1

}

map.clear();//清空集合

System.out.println("清空数据："+map);//清空数据：{}

//TreeMap自然排序是遵循字典排序，自定义排序与HashSet相类似

TreeMap map1=new TreeMap();

map1.put(4, "a");

map1.put(2, "a");

map1.put(3, "a");

map1.put(1, "a");

System.out.println("TreeMap："+map1);//TreeMap：{1=a, 2=a, 3=a, 4=a}

TreeMap map2=new TreeMap();

map2.put("b", "b");

map2.put("c", "c");

map2.put("d", "d");

map2.put("a", "a");

map2.put("ab", "ab");

System.out.println("TreeMap："+map2);//TreeMap：{a=a, ab=ab, b=b, c=c, d=d}

}

}

6.collection

package demo;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

public class Collectiontest {

public static void main(String[] args) {

// TODO 自动生成的方法存根

ArrayList list=new ArrayList();

list.add("b");//第一个，索引下标0

list.add("cd");//第二个，索引下标1

list.add("ca");//允许使用重复元素

list.add("a");

list.add("1");

System.out.println("按默认方式存入数据:"+list);//按默认方式存入数据:[b, cd, ca, a, 1]

Collections.reverse(list);

System.out.println("反转List中元素的顺序:"+list);//反转List中元素的顺序:[1, a, ca, cd, b]

Collections.shuffle(list);

System.out.println("对List中元素进行随机排序:"+list);//对List中元素进行随机排序:[a, 1, ca, cd, b]

Collections.sort(list);

System.out.println("List集合字典升序排序:"+list);//List集合字典升序排序:[1, a, b, ca, cd]

System.out.println("输出最大："+Collections.max(list));//输出最大：cd

System.out.println("输出最小："+Collections.min(list));//输出最小：1

Collections.swap(list, 0, 4);//

System.out.println("将指定list集合中的i处元素和j处元素进行交换后:"+list);//将指定list集合中的i处元素和j处元素进行交换后:[cd, a, b, ca, 1]

Student s1=new Student(14,"zhangsan");

Student s2=new Student(12,"lisi");

Student s3=new Student(13,"wangwu");

Student s4=new Student(11,"suiliu");

ArrayList stus=new ArrayList();//自定义排序

stus.add(s1);

stus.add(s2);

stus.add(s3);

stus.add(s4);

for(Student stu:stus) {

System.out.print(stu.name+","+stu.age+" ");//zhangsan,14 lisi,12 wangwu,13 suiliu,11

}

Collections.sort(stus,new Student());//按照指定方法排序

System.out.println();

for(Student stu:stus) {

System.out.print(stu.name+","+stu.age+" ");//suiliu,11 lisi,12 wangwu,13 zhangsan,14

}

Student ss=Collections.min(stus,new Student());

System.out.println(ss.name+"输出最大："+ss.age);//suiliu输出最大：11

}

}

class Student implements Comparator{

int age;

String name;

public Student() {

}

public Student(int age,String name) {

this.name=name;

this.age=age;

}

@Override

public int compare(Student arg0, Student arg1) {//根据年龄升序排列

// TODO 自动生成的方法存根

if(arg0.age>arg1.age) {

return 1;

}else if(arg0.age

return -1;

}else {

return 1;

}

}

}