1.HashSet集合
HashSet具有以下特点
(1)不能保证元素的排列顺序
(2)不可重复
(3)HashSet不是线程安全的
(4)集合元素可以是null
Set集合的初始化：
import java.util.HashSet;
import java.util.Set; 需事先声明
Set s=new HashSet();
常用方法：举例eg.
s.add(1);//添加
s.remove(1);//移除
s.contains(“kiana”)//判断元素是否在集合中，返回值为Boolean型
s.clear();//清空集合
s.size()//获取集合的元素个数,返回值为整形
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Set s=new HashSet();//set集合初始化
// s.add(1);//添加
// s.add("kiana");
// System.out.println(s);
// s.remove(1);//移除
// System.out.println(s);
// System.out.println(s.contains("kiana"));//判断元素是否在集合中，结果为Boolean型
// System.out.println(s.contains(1));
// s.clear();//清空集合
// System.out.println(s);
s.add("a");
s.add("b");
s.add("c");
s.add("d");
*//使用迭代器遍历集合
Iterator it=s.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}*
***//for each迭代集合
for(Object obj:s){//这个意思是说把s的每一个值取出来赋值给obj，直到循环s的所有值
System.out.println(obj);
}***
System.out.println(s.size());//获取集合的元素个数
s.add("d");//s里存的值是不重复的
System.out.println(s);
System.out.println(s.size());
s.add(null);//s集合可以存null
System.out.println(s);
//如果想要集合存同样类型的对象 要使用泛型
//Set<String>s=new HashSet<String>(); String类型集合
//Set s=new HashSet();等价于Set <Object>s=new HashSet<Object>();可以存任何类型的集合
}
}
运行结果：
a
b
c
d
a
b
c
d
4
[a, b, c, d]
4
[null, a, b, c, d]1.5.TreeSet集合
TreeSet特点
与HashSet集合类似，除此之外
(1)TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
(2)TreeSet支持二种排序方法：自然排序和定制排序 默认情况下TreeSet采用自然排序
初始化
import java.util.Set;
import java.util.TreeSet;
Set s= new TreeSet()
遍历集合 （下面例子为泛型Integer类型）
使用迭代器遍历集合
*// Iterator it=s.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
for each迭代集合
for(Integer i:s){
System.out.println(i);
}排序方式
（1）自然排序
public class Tree{
public static void main(String[] args) {
Set s= new TreeSet();
s.add(2);
s.add(1);
System.out.println(s);
}
}
运行结果：
[1, 2]（2）定制排序
eg.把person对象存到TreeSet中并且按照年龄排序
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class Tree{
public static void main(String[] args) {
Person p1 = new Person("kiana", 16);
Person p2 = new Person("banya", 14);
Person p3 = new Person("yayizi", 17);
Person p4 = new Person("teriri", 14);
Set<Person> s = new TreeSet<Person>();
s.add(p1);
s.add(p2);
s.add(p3);
s.add(p4);
for (Person p : s) {
System.out.println(p.name + " " + p.age);
}
}
}
class Person implements Comparator<Person> {//把person对象存到TreeSet中并且按照年龄排序
String name;
int age;
public Person(String name,int age){
this.age=age;
this.name=name;
}
public int compare(Person o1,Person o2) {
if(o1.age>o2.age){
return 1;
}else if(o1.age>o2.age){
return -1;
}else
return 0;
}
}2.List集合
List集合特点：
（1）List代表一个元素有序，且可重复的集合，集合中的每个元素都有其对应的顺序索引
（2）List允许使用重复元素，可以通过索引来访问指定位置的集合元素
（3）List默认按元素添加顺序设置元素的索引
（4）List集合里添加了一些根据索引来操作的集合元素方法
初始化
import java.util.ArrayList;
import java.util.List;
Listlis=new ArrayList(); //定义一个泛型为String类型的List集合
import java.util.ArrayList;
import java.util.List;
List<String>lis=new ArrayList<String>();//
public class ListArrayList {
public static void main(String[] args) {
List<String>lis=new ArrayList<String>();
lis.add("kaina");
lis.add("Mei");
lis.add("Bronya");
lis.add("Sakura");
lis.add("Terere");
lis.add("Terere");
System.out.println(lis);
System.out.println(lis.get(0));//通过索引来访问指定位置的集合元素
lis.add(1,"Theresa");
System.out.println(lis);
List<String>l=new ArrayList<String>();
l.add("a");
l.add("b");
lis.addAll(2,l);//addAll(i ,list)在元素下标为i的位置插入list集合
System.out.println(lis);
System.out.println(lis.indexOf("Terere"));//获取指定元素在集合中第一次出现的所有下标
System.out.println(lis.lastIndexOf("Terere"));//获取指定元素在集合中最后一次出现的所有下标
lis.remove("Terere");//根据集合中的元素移除数据
System.out.println(lis);
lis.remove(7);
System.out.println(lis);//根据下标移除数据
lis.set(2,"Terere");//根据指定索引下标修改元素
System.out.println(lis);
List sublist=lis.subList(2,4);//根据索引下标位置来截取一段元素形成一个新的集合；
// 截取时包含开始的索引不包含结束的索引
System.out.println(sublist);
System.out.println(lis.size());
for(String s:lis){//遍历
System.out.println(s);
}
}
}
运行结果：
[kaina, Mei, Bronya, Sakura, Terere, Terere]
kaina
[kaina, Theresa, Mei, Bronya, Sakura, Terere, Terere]
[kaina, Theresa, a, b, Mei, Bronya, Sakura, Terere, Terere]
7
8
[kaina, Theresa, a, b, Mei, Bronya, Sakura, Terere]
[kaina, Theresa, a, b, Mei, Bronya, Sakura]
[kaina, Theresa, Terere, b, Mei, Bronya, Sakura]
[Terere, b]
7
kaina
Theresa
Terere
b
Mei
Bronya
Sakura3.Map集合
//像python中的字典 Map 用于保存具有映射关系的数据，因此Map集合里保存着二组值，key和value
//Map中的key和value都可以是任何引用类型的数据，Map中的key不允许重复，且key和value一一对应
public class map {
public static void main(String[] args) {
Map<String,Integer> m=new HashMap<String,Integer>();
//添加数据用put
m.put("b",1);
m.put("c",2);
m.put("e",2);
System.out.println(m);
System.out.println(m.get("b"));//根据key取值
m.remove("c");//根据key移除键值对
System.out.println(m);
System.out.println(m.size());//m集合的元素
System.out.println(m.containsKey("a"));//判断当前m集合是否包含指定的key
System.out.println(m.containsValue(10));//判断当前m集合是否存在当前值value
m.keySet();//获取m集合的key集合
m.values();//获取集合所有的value值
//遍历m集合，通过m.keySet();
Set<String>keys=m.keySet();
for (String key: keys){
System.out.println("key: "+key+" value:"+m.get(key));
}
}
}
运行结果：
{b=1, c=2, e=2}
1
{b=1, e=2}
2
false
false
key: b value:1
key: e value:23.5 TreeMap
TreeMap自然排序是字典排序
import java.util.*;
public class map {
public static void main(String[] args) {
//一般使用map集合不会使用过于复杂的对象作key
Map <Integer,String> map=new TreeMap<Integer, String>();
map.put(4,"a");
map.put(2,"e");
map.put(3,"c");
map.put(1,"d");
System.out.println(map);
Map map1=new TreeMap();
map1.put("a","a");
map1.put("c","c");
map1.put("b","b");
System.out.println(map1);
}
}
运行结果：
{1=d, 2=e, 3=c, 4=a}
{a=a, b=b, c=c}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
