Java中的集合

Java中的集合

Collection容器

Colletion接口定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。

Collection接口中定义的方法

int size()

获取集合容器中元素的个数

boolean isEmpty()

集合容器是否为空，即没有元素

void clear()

清空集合容器中的所有元素

boolean contains(Objectelement)

集合容器中是否存在某个元素

boolean add(Object element)

向集合容器中添加⼀个元素

boolean remove(Objectelement)

从集合容器中移除⼀个元素

booleancontainsAll(Collection c)

集合容器中是否包含⼀个容器中所有的元素

boolean addAll(Collection c)

将传⼊的集合容器c中的所有元素添加到当前的集合容器

boolean removeAll(Collectionc)

从当前集合容器中移除集合容器c中的所有元素

boolean retainAll(Collectionc)

当前集合容器和传⼊的集合容器之间是否存在交集

Object[] toArray()

将集合容器转换为⼀个对象数组

Iterator iterator()

迭代集合容器中的元素

 

Collections工具类

常用的方法

void sort(Collection c)

对集合中的元素按照⾃然顺序进⾏排序

Object max(Collection c)

获取集合中的最⼤元素，并且返回最⼤元素

Object min(Collection c)

获取集合中的最⼩元素，并且返回最⼩元素

boolean replaceAll(Collectionc, Object ele1, Object ele2)

元素替换，将集合中的所有元素ele1替换成ele2

 

案例：给对象进行排序

用户类中包含姓名和年龄属性，要求给多个用户按照年龄进行排序

 

让User对象实现Comparable<T>接⼜，实现⽅法

compareTo，⽅法返回值⼤于0表⽰当前对象⼤于⽤于对⽐

的对象，⼩于0表⽰当前对象⼩于⽤于对⽐的对象

packagetest;

 

public classPerson implements Comparable<Person>{

 

   privateString name;

   private int age;

  

   publicPerson(String name,int age) {

    

     this.name =name;

     this.age =age;

   }

 

   publicString getName() {

     return name;

   }

 

   public voidsetName(String name) {

     this.name =name;

   }

 

   public intgetAge() {

     return age;

   }

 

   public voidsetAge(int age) {

     this.age =age;

   }

 

   @Override

   public intcompareTo(Person o) {

     if(this.age>o.getAge()){

        return 1;

     }else{

        return -1;

     }

    

   }

 

   @Override

   publicString toString() {

    

     return "姓名："+this.name+" 年龄："+this.age;

   }

  

  

}

 

2、在测试类中调⽤Collections集合的sort⽅法对集合进⾏排

序

packagetest;

 

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.List;

 

importorg.junit.Test;

 

public classTest1 {

 

   @Test

   public voidtest() {

     List<Person> list = newArrayList<Person>();

 

     Person p1 = newPerson("张三",15);

     Person p2 = newPerson("李四",19);

     Person p3 = newPerson("王五",13);

     list.add(p1);

     list.add(p2);

     list.add(p3);

     System.out.println("排序前：");

     for (Personp : list) {

        System.out.println(p.toString());

     }

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

     System.out.println("排序后：");

     Collections.sort(list);

     for(Person p : list) {

        System.out.println(p.toString());

     }

   }

}

 

List容器

List容器中的数据有顺序，并且可以重复

ArrayList集合

add(Object obj)

向List集合容器中添加元素，元素可重复添加

int size()

获取List集合容器中元素的个数

get(int index)

从List集合中获取元素，返回Object

remove(Object obj)

从集合中删除元素

remove(int index)

从集合中删除元素

clear()

从集合中删除所有元素

contains(Object obj)

集合中是否存在某个元素，返回boolean值

 

 

示例：

public voidtest1(){

     List l = new ArrayList();//声明List集合容器器

     l.add("abc"); //向list容器器中添加⼀一个String对象

     l.add(true);//向list容器器中添加⼀一个Boolean对象

     l.add(1); //向list容器器中添加⼀一个Integer对象

     int size= l.size(); //获取集合中元素的个数

     System.out.println("集合中元素个数是："+size);

     Object obj = l.get(2); //获取集合中的元素，索引值从0开始

     System.out.println("集合中第3个元素是："+obj);

     System.out.println(l.toString());

     // l.remove("abc");//删除集合中的元素

     // l.remove(0); //删除集合中的元素，索引从0开始

     // l.clear(); //删除集合中所有元素

     System.out.println("abc是不不是在整个集合中？"+l.contains("abc"));

     System.out.println(l.toString());

   }

 

 

 

LinkedList集合

相对于ArrayList，LinkedList类中添加了⼀些处理列表两端元素的⽅法

addFirst(Object o)

向集合容器的顶部添加元素

addLast(Object o)

向集合容器的尾部添加元素

Object getFirst()

获取集合容器顶部元素

Object getLast()

获取集合容器尾部元素

Object removeFirst()

删除，并返回集合容器顶部元素

Object removeLast

删除，并返回集合容器尾部元素

 

 

示例：

public voidtest1(){

     LinkedList<Integer> list = newLinkedList<Integer>();

     list.add(1);

     list.add(2);

     list.add(3);

     list.add(4);

     list.add(5);

     list.addFirst(0); //向集合顶部添加⼀一个元素

     list.addLast(100); //向集合尾部添加⼀一个元素

     System.out.println("被删除的对象是："+list.removeFirst());//删除顶端元素，并且返回被删除的元素

     System.out.println("被删除的对象时："+list.removeLast());//删除尾部元素，并且返回被删除的元素

     System.out.println("集合的第⼀一个元素是："+list.getFirst());//获取顶部元素

     System.out.println("集合中的最后⼀一个元素是："+list.getLast());//获取底部元素

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

   }

 

 

Set容器

Set容器中的数据对象没有顺序，并且不可重复

HashSet的常用方法

add(Object obj)

向Set集合容器中添加⼀个元素，元素不可重复添加

int size()

获取Set集合容器中所有元素的个数

iterator()

应⽤迭代器获取Set集合中所有的元素

remove(Object obj)

从Set集合容器中移除元素

clear()

删除Set集合容器中的所有元素

contains(Object obj)

判断Set 集合容器中是否存在某个严肃，返回boolean值

 

 

题目：随机⽣成5个0-10之间的整数，控制台输出这5个数字，要求数字不可以重复

1、将随机⽣成的数字存到Set集合容器中

2、⽤迭代器输出Set容器中的所有元素

 

Set<Integer>set = new HashSet<Integer>();

     while(true){

     int x =(int) (Math.random()*10);

     System.out.println(x);

     if(set.size()< 5){

        set.add(x);

     }else{ //循环停⽌止

        break;

     }

     }

     System.out.println(set.toString());

 

 

Map容器

Map容器定义了储存“键(key)——值(value)映射对”的⽅法，简称“键值对”

Map提供的常用方法

put(Object key, Object value)

向Map集合中添加⼀条记录，记录是以键值对的形式存放的

Object get(Object key)

从Map集合中通过key来获取value

Set keySet()

获取map集合中所有的key

Set entrySet()

获取Map集合中所有的记录(key-value对象Entry)

 

示例：

public voidtest1(){

     Map<String, String> map = newHashMap<String, String>();

     map.put("no1", "Beijing"); // 向map集合中添加⼀一条记录

     map.put("no2", "ShangHai");

     map.put("no3", "HangZhou");

     map.put("no4", null);

     map.put(null, "xxxx");

     Set<Map.Entry<String, String>>enSet = map.entrySet();

     Iterator<Map.Entry<String,String>> itr = enSet.iterator();

     while(itr.hasNext()){

     Map.Entry<String, String> entry =itr.next();

     String key = entry.getKey();

     String value = entry.getValue();

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

     }

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

     for(Map.Entry<String,String> entry : map.entrySet()){

     String key = entry.getKey();

     String value = entry.getValue();

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

     }

}

 

注意点：

Hashtable集合

Hashtable和HashMap⽤法⼀致，以下是两者的不同点

HashMap是线程不安全的，Hashtable是线程安全的

HashMap允许有null的键和值，Hashtable不允许