ArrayList集合
单列集合,底层数组结构,查询快,增删慢,可重复,按照添加的顺序存储输出.
*Collections是用来操作单列集合的工具类
public static addAll(Collection<? super T> c, T... elements) //往集合中一次添加多个元素
public static void sort(List<T> list)//对集合进行排序
public static int binarySearch(List list, T key) // 使用二分查找法,查找List集合中指定元素的索引,使用二分法之前必须先对集合中的元素进行排序
public static void swap(List<?> list, int i, int j) //对指定的两个元素的索引相互交换位置
public static T max(Collection<? extends T> coll) //获取集合中元素的最大值
public static T min(Collection<? extends T> coll) //获取集合中元素的最小值
public static void reverse(List<?> list) //对集合中的元素进行反转
public static void shuffle(List<?> list) //对集合中的元素进行随机置换,洗牌
自然排序
public int compareTo(Student s) {
int num = this.age-s.age;//升序
//int num2 = num == 0 ? this.name.compareTo(s.name) : num;
if (num==0){
int i = this.name.compareTo(s.name);
num=i;
}
return num;
}
比较器排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o1.getAge()-o2.getAge();
if (num==0){
int i = o1.getName().compareTo(o2.getName());
num=i;
}
return num;
}
});
LinkList
LinkList集合地层是链表,查询慢,增删快,
与arraylist集合一样有序,可以重复,多了几种对头尾元素的几种操作方法
HashSet集合
Collection接口
List: 有索引、有序、元素可以重复
ArrayList:数组结构(查询块、增删慢)
LinkedList:链表结构(查询慢、增删快)
Set:
没有索引、无序、元素不能重复
HashSet: 哈希表结构
TreeSet: 红黑树结构
遍历的顺序与添加的顺序不一致,没有索引,不能用普通for循环遍历,只能用增强for循环或者迭代器遍历``
public class Test {
public static void main(String[] args){
HashSet hs = new HashSet();
Student s1 = new Student("张三",15);
Student s2 = new Student("李四",16);
Student s3 = new Student("王五",17);
Student s4 = new Student("张三",15);
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
System.out.println(s1.hashCode());
System.out.println(s4.hashCode());
//s1的哈希值与s4的哈希值不一样,尽管对象的属性值相同,但是s1和s4是两个对象,所以有两个不同的哈希值,所以都能添加到hashset集合中
}
}
hashset集合保证元素的唯一性原理
- 计算存储对象的哈希值
- 当前存储对象与已经存储的对象的哈希值相比较,如果两个对象的哈希值相同的话,就比较两个元素的equals值
- 比较两个对象的equals值,如果两个对象的哈希值与equals值相同,则认为两个元素是同一个对象
我们在存储对象的时候,需要在实体类中重写hashset和equals方法以保证元素的唯一性.存储的过程与取出的过程不一致,无序,无索引,元素不重复
TreeSet集合
元素有序,可以按照一定的规则进行排序,具体排序方式取决于构造方法
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator comparator) :根据指定的比较器进行排序
没有带索引的方法,所以不能使用普通for循环遍历
由于是Set集合,所以不包含重复元素的集合
存储的String Integer类型的数据都能按照字典顺序排列,应为在String 和Interger类中底层都已经实现了Comparable类,重写了compareTo方法,我们在存储实体类对象的时候就需要实现Comparator接口,根据指定的比较器进行排序
public class Teacher implements Comparable<Teacher>{
private String name;
private int age;
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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 Teacher(){}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Teacher o) {
int num = this.getAge()-o.age;
if (num==0){
int i = this.getName().compareTo(o.name);
num = i;
}return num;
}
}
import java.util.TreeSet;
public class Test {
public static void main(String[] args){
TreeSet<Teacher> ts = new TreeSet();
Teacher t1 = new Teacher("张三",15);
Teacher t2 = new Teacher("李四",17);
Teacher t3 = new Teacher("王五",19);
Teacher t4 = new Teacher("张三",15);
ts.add(t1);
ts.add(t2);
ts.add(t3);
ts.add(t4);
for (Teacher t : ts) {
System.out.println(t);
}
}
}
//执行结果,实现Comparable接口重写ToCompara方法
//Teacher{name='张三', age=15}
//Teacher{name='李四', age=17}
//Teacher{name='王五', age=19}
比较器排序
import java.util.Comparator;
import java.util.TreeSet;
public class Test2 {
public static void main(String[] args){
TreeSet<Teacher> ts = new TreeSet(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
int num = o1.getAge()-o2.getAge();
if (num==0){
int i = o1.getName().compareTo(o2.getName());
num=i;
}
return num;
}
}) ;
Teacher t1 = new Teacher("张三",15);
Teacher t2 = new Teacher("李四",17);
Teacher t3 = new Teacher("王五",19);
Teacher t4 = new Teacher("张三",15);
ts.add(t1);
ts.add(t2);
ts.add(t3);
ts.add(t4);
for (Object t : ts) {
System.out.println(t);
}
}
}
//结果与上面结果相同
Map集合遍历方法一
//获取所有的键的集合
Set<String> keys = map.keySet();
//遍历所有的键
for (String key : keys) {
//通过每一个键得到对应的值
String s = map.get(key);
System.out.println(key+":"+s);
}
Map集合遍历方法二
//得到所有的键值对集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//遍历所有的键值对集合得到每一个键值对
for (Map.Entry<String, String> entry : entries) {
// 通过键值对得到对应的键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+":"+value);
}
统计字符出现的个数
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class Demo {
public static void main(String[] args){
HashMap<Character,Integer> hm = new HashMap<>();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串");
String s = scanner.nextLine();
for (int i=0;i<s.length();i++){
char c = s.charAt(i);
if (hm.containsKey(c)){
Integer i1 = hm.get(c);
i1++;
hm.put(c,i1);
}else {
hm.put(c,1);
}
}
Set<Character> chs = hm.keySet();
for (Character ch : chs) {
Integer i = hm.get(ch);
System.out.println(ch+"("+i+")");
}
}
}