集合
集合概述
Java集合类存放于java.util包中，是一个用来存放对象的容器。
1.集合只能存放对象。比如你存一个int型数据1放到集合中，其实他是自动转换成Integer类后存入的，Java中每一个基本类型都对应一个引用类型。
2.集合存放的是多个对象的引用，对象本身还是放到堆内存中。
3.集合可以存放不同类型，不限数量的数据类型。
Java集合可分为Set、List和Map三种体系
Set：无序，不可重复的集合。
List：有序，可重复的集合。
Map：具有映射关系的集合。
1. HashSet
HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类，我们大多数说Set集合指的都是HashSet。
HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet具有以下特点：
不能保存元素的排列顺序。
不可重复。
HashSet不是线程安全的。
集合元素可以使用null。
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置。
如果两个元素的equals()方法返回true，但他们的hashCode()返回值不相等，hashSet将会把他们存储在不同的位置，但依然可以添加成功。
hashCode()方法：
HashSet集合判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。
如果两个对象通过equals()方法返回true，这两个对象的hashCode值也相等。
实例：
public class Test1 {
public static void main(String[] args) {
Set set = new HashSet();
//添加
set.add(1);
set.add("a");
System.out.println(set);
//移除
set.remove(1);
System.out.println(set);
//是否存在
System.out.println(set.contains(1));
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("d");//set集合存的值是不存在的
System.out.println(set);
//使用迭代器遍历集合
Iterator it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//for each迭代集合
for (Object obj : set){//把set的每一个值取出来，赋值给obj，直到循环set的所有值
System.out.println(obj);
}
//获取集合的元素个数
System.out.println(set.size());
//如果让集合只能存同样类型的对象，使用泛型
Set<String> set1 = new HashSet<String>();
set1.add("sbc");
//set1.add(1);
}
}
2. TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
TreeSet支持两种排序方法：自然排序和定制排序。默认使用自然排序。
自然排序：
TreeSet会调用集合元素的compareTo（Object obj）方法来比较元素之间的大小关系，然后将集合元素按升序排列。
如果this>obj,返回正数1
如果this<obj,返回负数1
如果this=obj，返回0，则认为这两个对象相等。
必须放入同样类的对象（默认会进行排序）否则可能会发生类型转换异常.我们可以使用泛型来进行限制。
实例：
public class Test3 {
public static void main(String[] args) {
Person p1 = new Person("张三",23);
Person p2 = new Person("lisi",16);
Person p3 = new Person("mazi",12);
Person p4 = new Person("didi",27);
Set<Person> set = new TreeSet<Person>(new Person());
set.add(p1);
set.add(p2);
set.add(p3);
set.add(p4);
for (Person p : set){
System.out.println(p.name+" "+p.age);
}
}
}
//把Person对象存到TreeSet中并且按照年龄排序
class Person implements Comparator<Person>{
int age;
String name;
public Person(){
}
public Person(String name,int age) {
this.age = age;
this.name = name;
}
@Override
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;
}
}
}
3. List与ArrayList
List代表一个元素有序且可重复的集合，集合中的每个元素都有其对应的顺序索引。
List允许使用重复元素，可以通过索引来访问指定位置的集合元素。
List默认按元素的添加顺序设置元素的索引。
List集合里添加了一些根据索引来操作集合元素的方法。
实例：
public class Test4 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("d");//第一个，索引下标为0
list.add("a");//索引下标为1
list.add("b");//索引下标为2
list.add("c");//索引下标为3
list.add("d");//允许使用重复元素
System.out.println(list);
//通过索引来访问指定位置的集合元素
System.out.println(list.get(2));
//在指定索引下标位置插入数据
list.add(1,"f");
System.out.println(list);
List<String> l = new ArrayList<String>();
l.add("123");
l.add("456");
//在指定索引下标的位置插入集合
list.addAll(2,l);
System.out.println(list);
//获取指定元素在集合中第一次出现的索引下标
System.out.println(list.indexOf("d"));
//获取指定元素在集合中最后一次出现的索引下标
System.out.println(list.lastIndexOf("d"));
//根据指定的索引下标移除元素
list.remove(2);
System.out.println(list);
//根据指定的索引下标修改元素
list.set(1,"ff");
System.out.println(list);
//根据索引下标的起始位置截取一段元素，形成一个新的集合，截取的时候包含开始的索引，不包含结束时的索引
List<String> sublist = list.subList(2,4);
System.out.println(sublist);
//集合长度
System.out.println(list.size());
}
}
4. Map
Map
Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组用于保存Map里的value值。
Map中的key与value都可以是任何引用类型的数据。
Map中的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较中返回false。
key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的，确定的value值。
实例：
public class Test5 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
//添加数据
map.put("b",1);
map.put("d",2);
map.put("e",2);
System.out.println(map);
//根据key取值
System.out.println(map.get("d"));
//根据key移除键值对
map.remove("e");
System.out.println(map);
//map集合的长度
System.out.println(map.size());
//判断当前map集合是否包含指定的key
System.out.println(map.containsKey("b"));
//判断当前map集合是否包含指定的value
System.out.println(map.containsValue(2));
//获取map集合的key集合
Set<String> keys = map.keySet();
//获取集合的所有value值
map.values();
//遍历Map集合，通过map.keySet()
for (String key : keys){
System.out.println("key:"+key+",value:"+ map.get(key));
}
//通过map.entrySet()遍历
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String,Integer> en : entries){
System.out.println("key:"+en.getKey()+",value:"+ en.getValue());
}
}
}
TreeMap
TreeMap存储Key-Value对时，需要根据key对key-value对进行排序，TreeMap可以保证所有的Key-Value对处于有序状态。
TreeMap的Key的排序：
自然排序：TreeMap的所有的Key必须实现Comparable接口，而且所有的Key应该是同一类的对象，否则将会抛出ClasssCastException。
实例：
public class Test6 {
public static void main(String[] args) {
//TreeMap的自然排序是字典排序
Map<Integer,String> map1 = new TreeMap<Integer,String>();
map1.put(8,"b");
map1.put(9,"d");
map1.put(5,"a");
map1.put(3,"c");
System.out.println(map1);
Map<String,String> map = new TreeMap<String,String>();
map.put("b","f");
map.put("a","s");
map.put("b","a");
map.put("c","d");
map.put("1","e");
map.put("10","h");
System.out.println(map);
}
}
5. 操作集合的工具类：collections
Collections是一个操作Set、Map、List等集合的工具类。
Collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作：
reverse（List）：反转List中元素的顺序。
shuffle（List）：对List集合元素进行随机排序。
sort（List）：根据元素的自然顺序对指定List集合元素按升序排序。
swap（List，int，int）：将指定List的集合中的i处元素和j处元素进行交换。
实例：
public class Test7 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("b");
list.add("bd");
list.add("ce");
list.add("a");
list.add("1");
System.out.println(list);
//反转List中元素的顺序
Collections.reverse(list);
System.out.println(list);
//对List集合元素进行随机排序
Collections.shuffle(list);
System.out.println(list);
//根据元素的自然顺序对指定List集合元素按升序排序
Collections.sort(list);
System.out.println(list);
//将指定List的集合中的i处元素和j处元素进行交换
Collections.swap(list,0,4);
System.out.println(list);
//返回最小值
System.out.println(Collections.max(list));
//返回最大值
System.out.println(Collections.min(list));
//返回指定集合元素出现次数
System.out.println(Collections.frequency(list,"a"));
//使用新值替换掉List对象的所有旧值
Collections.replaceAll(list,"a","aa");
System.out.println(list);
}
}
sort（List，Comparator）：根据指定的Comparator产生的顺序对List集合元素进行排序。
实例：
public class Test8 {
public static void main(String[] args) {
Student s1 = new Student(18,"小明");
Student s2 = new Student(25,"小花");
Student s3 = new Student(13,"小华");
Student s4 = new Student(16,"小明");
List<Student> stus = new ArrayList<Student>();
stus.add(s1);
stus.add(s2);
stus.add(s3);
stus.add(s4);
for (Student stu : stus){
System.out.println(stu.name+" "+stu.age);
}
System.out.println("-------------------------");
Collections.sort(stus,new Student());
for (Student stu : stus){
System.out.println(stu.name+" "+stu.age);
}
}
}
class Student implements Comparator<Student> {
int age;
String name;
public Student() {
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
//根据年龄升序排列
@Override
public int compare(Student o1, Student o2) {
if (o1.age > o2.age) {
return 1;
} else if (o1.age < o2.age) {
return -1;
} else {
return 0;
}
}
}
浙公网安备 33010602011771号