java中的集合框架（Set、List、Map）及其实现类

下面看一下ArrayList的增删改查操作：

package test;

import java.util.ArrayList;

public class testArrayList {

/**

• 集合框架

• 集合：一个对象，用来储存其他多个对象

• ArrayList 能更好的代替数组

• @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

ArrayList list = new ArrayList();

//新增

list.add(“今天周日”);

list.add(“明天周一”);

list.add(0, “昨天周六”);

//修改

list.set(1, “今天周日不上晚自习”);

System.out.println(list);

//查找

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

//删除

System.out.println(list.remove(2));

//遍历

for (String string : list) {

System.out.println(string);

}

}

}

linkedList和Vector的增删改查都是一样的

Set接口：

无序无下标，元素不可以重复

set接口的方法都是从Collection接口中继承而来，

add(E e) ：向集合中添加一个元素，返回值类型为：boolean

contains(Object o)：判断集合中是否包含某个元素，返回值类型为：boolean

remove(Object o)： 移除某一个元素 ，返回值类型为：boolean

size() ：返回集合中的有效元素个数，返回值类型为：int

HashSet实现类的简单增删改查以及常用方法：

package test;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Set;

public class test {

/**

• Set 元素无顺序 内容不可重复

• 方法全部继承自Collection接口

• 遍历：迭代遍历或者for-each遍历

*/

public static void main(String[] args) {

//set中判断元素不重复值的是元素内容不重复

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

Set set = new LinkedHashSet<>();

String s1 = new String(“aaa”);

String s2 = new String(“bbb”);

String s3 = new String(“ccc”);

String s4 = new String(“aaa”);

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

//forEach遍历

for (String string : set) {

System.out.print(string+“\t”);

}

System.out.println();

//删除操作

set.remove(s3);

//看set中是否包含一个对象

System.out.println(set.contains(s4));

//再次添加

System.out.println(set.add(“aaa”));

//迭代遍历

Iterator it = set.iterator();

while(it.hasNext()){

System.out.print(it.next()+“\t”);

/*Object o = it.next();

System.out.println(o);*/

}

}

}

TreeSet：

对Set集合进行按照一定顺序进行从小到大排列：

比如说下面的程序，Set中放一个Worker对象，要想使他进行排列必须得先指定他按照什么顺序排列，先先给他一个排序规则这样JVM才知道要怎么做。也就是Worker类要实现 Comparable接口

package test;

import java.util.Set;

import java.util.TreeSet;

public class TestTreeMap2 {

public static void main(String[] args) {

Set set = new TreeSet(); //对元素进行升序排列

set.add(new Worker(“hansf”,38,10.0));

set.add(new Worker(“awang”,48,20.0));

set.add(new Worker(“kangkang”,36,30.0));

set.add(new Worker(“make”,58,40.0));

set.add(new Worker(“songtf”,58,50.0));

//遍历

for(Worker worker:set){

System.out.println(worker);

}

}

}

//要实现Comparable接口才可以进行按照规则排序！！！！！

public class Worker implements Comparable{

private String name;

private int age;

private double salary;

public Worker(String name, int age, double salary) {

super();

this.name = name;

this.age = age;

this.salary = salary;

}

public Worker() {

super();

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public double getSalary() {

return salary;

}

public void setSalary(double salary) {

this.salary = salary;

}

public void work(){

System.out.println(name+“work”);

}

@Override

public String toString() {

return “Worker [name=” + name + “, age=” + age + “, salary=” + salary

• “]”;

}

return false;

} else if (!name.equals(other.name))

return false;

if (Double.doubleToLongBits(salary) != Double

.doubleToLongBits(other.salary))

return false;

return true;

}

@Override

public int compareTo(Worker o) {

// 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

//以年龄为例

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

return -1;

}else if(this.age==o.getAge()){

if(this.salary<o.getSalary()){

return -1;

}else if(this.salary==o.getSalary()){

return 0;

}else{

return 1;

}

}else{

return 1;

}

}

}

Map集合

Map集合的一个元素是由一个键(key)和一个值(value)组成的

key不允许重复，value允许重复

Map集合常用方法：

V put(K key, V value) ：向集合中添加一个元素，

若集合中包含这个key，使用v覆盖掉，并且返回原来key所对应的value

V remove(Object key)：根据key删除集合中元素，并且返回删除的value

size()：获取集合中有效的键值对个数

boolean containsKey(Object key) ：如果此集合包含指定键所对应的键值对，则返回 true。

boolean containsValue(Object value) ： 如果集合中包含对应的value 则返回true

遍历方式

①键遍历 能够获取到键和值

1.键遍历

获取所有的key对应的set集合 Set keySet()

Set set = map.keySet();

循环遍历set集合 获取key 还可以根据key获取对应的value

for(Integer key:set){

String value = map.get(key); //根据键获取值

System.out.println(key+“----”+value); //获取所有的key

}

2值遍历 只能够获取到值（value）

获取所有的value 存放在集合中

Collection values = map.values();

遍历集合

for(String value:values){

System.out.println(value);

}

键值对遍历 能够获取到键和值

将key和value 封装成一个对象Map.Entry<Integer,String>，把封装的对象存放在集合里面

entrySet() :能够获取 键值对对象 存放的集合

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

遍历集合 获取对应键和值

for(Map.Entry<Integer, String> entry:set){

Integer key = entry.getKey();

String value = entry.getValue();

System.out.println(key+“—”+value);

}

Map的常用方法示例：

package test;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class testMap {

public static void main(String[] args) {

// TODO Auto-generated method stub

Map<String, Integer> map = new HashMap<String, Integer>();

//增

map.put(“a”, 1);

map.put(“b”, 2);

map.put(“c”, 3);

map.put(“d”, 4);

map.put(“e”, 5);

//查

System.out.println(map.get(“c”));

//改

map.put(“c”, 33);

System.out.println(map.get(“c”));

//删

map.remove(“d”);

//遍历

System.out.println(map);

//查找map中是否包含指定的key

System.out.println(map.containsKey(“e”));

//查找map中是否包含指定的value

map.containsValue(“5”);

//长度

System.out.println(map.size());

System.out.println();

//遍历key

System.out.println(“遍历key”);

Set set = map.keySet();

for (String string : set) {

Integer val = map.get(string);

System.out.print(string+“\t”+val+“\n”);