集合的定义
集合的定义
集合是用来干啥的:
集合就相当于一个人容器,用来存储数据的
Collection:
JDK 不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常
用来传递collection,并在需要最大普遍性的地方操作这些 collection。
集合与数组的区别
1.数组的长度是固定的,集合中的长度是可以改变的
2.数组中可以存储基本数据类型和引用数据类型,集合中只能存储引用数据类型
3.数组中只能存储一种数据类型,集合中可以存储多种数据类型
集合的接口
public class Student {
// 成员变量(属性)
private int id;//学号
private String name;//姓名
private int age;//年龄
private String sex;//性别
public Student() {
}
public Student(int id, String name, int age, String sex) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
`
list接口
List集合存储的数据是有顺序、可以重复、有索引
ArrayList
ArrayList:底层实现是数组,查询快、增删慢,线程不安全,效率高(特别重要)
public class StudentTest {
public static void main(String[] args) {
// 集合中的尖括号叫做泛型,泛型其实就是集合中存储数据的一个类型
// ArrayList<String> arrayList = new ArrayList<>();
因为集合的泛型是String,所以只能存储String类型的数据
arrayList.add(123);
// arrayList.add("aaa");
// 创建一个ArrayList集合,用来从来存储学生信息
ArrayList<Student> arrayList = new ArrayList<>();
// 创建Student对象,并给属性赋值
Student student1 = new Student(1,"张三",20,"男");
Student student2 = new Student(2,"李四",18,"女");
Student student3 = new Student(3,"王五",22,"男");
Student student4 = new Student(4,"赵六",19,"女");
// 添加到集合中
arrayList.add(student1);
arrayList.add(student2);
arrayList.add(student3);
arrayList.add(student4);
// 第一种输出方法:使用增强for循环遍历并输出
for (Student student : arrayList) {
System.out.println(student);
}
System.out.println("-----------------------------------------------------------");
// 第二种输出方法:使用迭代器(iterator)
// 使用迭代器遍历集合中的每个元素
Iterator<Student> iterator = arrayList.iterator();
// 如果集合中有元素就一直循环,知道集合中没有元素
while (iterator.hasNext()){
// 获取迭代出的元素
Student next = iterator.next();
// 输出迭代出的元素
System.out.println(next);
}
// 求这个案例中学生的平均年龄、最大年龄和学生人数
}
}
public class Test01 {
public static void main(String[] args) {
// 创建一个ArrayList集合
ArrayList arrayList = new ArrayList();
// 添加元素
arrayList.add("aaa");
arrayList.add(111);
arrayList.add(222);
arrayList.add("aaa");
// 在指定的位置插入指定的元素
arrayList.add(1,"qqq");
// 想要得到集合中的元素,是需要遍历的
System.out.println(arrayList);
// 输出集合中元素的个数
System.out.println("集合中一共有"+arrayList.size()+"个元素");
// 修改集合中的元素
arrayList.set(2,"bbb");
// 删除集合中的元素(可以根据元素删除,也可以根据索引删除),根据元素时候,如果有相同的元素那就删除前面的
arrayList.remove("aaa");
// 使用增强for,遍历输出集合中的元素,Object是所有类的父类,Object可以是所有类
for (Object o : arrayList) {
System.out.println(o);
}
System.out.println("--------------------------------------------------");
// 获取集合中某个元素
System.out.println(arrayList.get(2));
// 清空集合中所有的元素
arrayList.clear();
System.out.println("--------------------------------------------------");
for (Object o : arrayList) {
System.out.println(o);
}
}
}
LinkList
LinkedList:底层实现是数组,增删快、查询慢,线程不安全,效率高
public class Test02 {
public static void main(String[] args) {
// 创建一个LinkedList集合
LinkedList linkedList = new LinkedList();
// 给LinkedList中添加数据
linkedList.add(111);
linkedList.add("aaa");
linkedList.add("bbb");
linkedList.add(111);
给这条数据添加到集合的第一个位置
// linkedList.addFirst("qqq");
给这条数据添加到集合的最后一个位置
// linkedList.addLast("www");
// 删除集合中的元素(可以根据元素删除,也可以根据索引删除),根据元素时候,如果有相同的元素那就删除前面的
// linkedList.remove(2);
// linkedList.remove("bbb");
// linkedList.removeFirst();
// linkedList.removeLast();
// 修改集合中的数据
linkedList.set(2,"123");
System.out.println("集合中一共有"+linkedList.size()+"条数据");
// 遍历输出集合中所有的元素
for (Object o : linkedList) {
System.out.println(o);
}
}
}
案例作业
1.创建一个学生类,属性有:学号、姓名、年龄、性别,属性创建为私有的,
2.在测试类创建一个LinkedList集合,
3.创建5个学生对象并存到LinkedList集合中
4.求这个案例中学生的平均年龄、最大年龄和学生人数
public class Lswzye {
// 1.创建一个学生类,属性有:学号、姓名、年龄、性别,属性创建为私有的,
2.在测试类创建一个LinkedList集合,
3.创建5个学生对象并存到LinkedList集合中
4.求这个案例中学生的平均年龄、最大年龄和学生人数
public static void main(String[] args) {
int max =0 ,sum = 0,avg = 0;
// 创建集合
LinkedList<Student> linkedList = new LinkedList<>();
// 创建五个学生对象
linkedList.add(new Student(1,"张三",20,"男"));
linkedList.add(new Student(2,"李四",18,"女"));
linkedList.add(new Student(2,"李四",18,"女"));
linkedList.add(new Student(4,"赵六",19,"女"));
linkedList.add(new Student(5,"沈七",23,"女"));
for (int i = 0; i<linkedList.size();i++)
{
sum+=linkedList.get(i).getAge();
if (linkedList.get(i).getAge()>max)
{
max =linkedList.get(i).getAge();
}
}
avg = sum/linkedList.size();
System.out.println("学生的平均年龄是"+avg+"\t学生年纪的最大值"+max+"\t一共有"+linkedList.size()+"个学生");
}
}
Vector
Vector:底层实现是数组,查询快、增删改慢,线程安全,效率低(没用)
set接口
Set集合存储的数据是没有顺序、不可以重复、没有索引
HashSet:底层是HashMap,数组+链表实现,不允许元素重复,无序
案例
public class Student {
private String name;
private int age;
private String sex;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name) &&
Objects.equals(sex, student.sex);
}
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return sex
*/
public String getSex() {
return sex;
}
/**
* 设置
* @param sex
*/
public void setSex(String sex) {
this.sex = sex;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + ", sex = " + sex + "}";
}
}
```java
public class Hashset {
public static void main(String[] args) {
HashSet<Student> s1 = new HashSet<>();
Student s2 = new Student("aaa",18,"男");
Student student3 = new Student("aaa",18,"男");
s1.add(s2);
s1.add(student3);
s1.add(new Student("BBB",19,"男"));
s1.add(new Student("BBB",19,"男"));
System.out.println();
System.out.println(s1);
System.out.println(s2.hashCode());
System.out.println(student3.hashCode());
System.out.println(s2.equals(student3));
}
}
TreeSet:底层实现是红黑二叉树,实现元素排序,排序案例如下
```java
public class Apple {
private String name;
private String color;
private int price;
public Apple() {
}
public Apple(String name, String color, int price) {
this.name = name;
this.color = color;
this.price = price;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
* @param color
*/
public void setColor(String color) {
this.color = color;
}
/**
* 获取
* @return price
*/
public int getPrice() {
return price;
}
/**
* 设置
* @param price
*/
public void setPrice(int price) {
this.price = price;
}
public String toString() {
return "Apple{name = " + name + ", color = " + color + ", price = " + price + "}";
}
}
public class TreeSet {
public static void main(String[] args) {
Apple apple1 = new Apple("红富士", "红色", 18);
Apple apple2 = new Apple("富士", "蓝色", 13);
Apple apple3 = new Apple("红士", "绿色", 19);
Apple apple4 = new Apple("士", "青色", 8);
// TreeSet排序
java.util.TreeSet<Apple> objects = new java.util.TreeSet<>(
new Comparator<Apple>() {
@Override
public int compare(Apple o1, Apple o2) {
return o2.getPrice()-o1.getPrice();
}
}
);
objects.add(apple1);
objects.add(apple2);
objects.add(apple3);
objects.add(apple4);
System.out.println(objects);
}
}
map接口
key-value键值对形式存储数据的
HashMap
hahmap:底层是数组+链表实现,无序(特别重要)
public class StudentTest2 {
public static void main(String[] args) {
// 1.创建一个学生类,属性有:学号、姓名、年龄、性别,属性创建为私有的
// 2.在测试类创建一个HashMap集合
// 3.创建3个学生对象并存到HashMap集合中
// 创建一个HashMap集合
HashMap<Integer, Student> hashMap = new HashMap<>();
// 创建3个学生对象并存到HashMap集合中
// Student student1 = new Student(1,"张三",20,"男");
// Student student2 = new Student(2,"李四",18,"女");
// Student student3 = new Student(3,"王五",22,"男");
// hashMap.put(1,student1);
// hashMap.put(2,student2);
// hashMap.put(3,student3);
hashMap.put(1,new Student(1,"张三",20,"男"));
hashMap.put(2,new Student(2,"李四",18,"女"));
hashMap.put(3,new Student(3,"王五",22,"男"));
// 通过keySet方法获取集合中所有的key值,并遍历
Set<Integer> integers = hashMap.keySet();
System.out.print("集合中key分别为:");
for (Integer integer : integers) {
System.out.print(integer+" ");
}
System.out.println("\n-------------------------------------------");
// 通过values方法获取集合中所有的value值,并遍历
Collection<Student> values = hashMap.values();
for (Student value : values) {
System.out.println("value值为:"+value);
}
System.out.println("-------------------------------------------------");
// 第一种遍历Map集合的方法:通过keySet方法获取集合中所有的key值,在通过key值获取集合所有的value值(推荐使用)
Set<Integer> integers1 = hashMap.keySet();
for (Integer integer : integers1) {
System.out.println("key值为:"+integer+",对应的value值为:"+hashMap.get(integer));
}
System.out.println("---------------------------------------------------");
// 第二种遍历Map集合的方法:通过泛型遍历
Set<Map.Entry<Integer,Student>> entrySet = hashMap.entrySet();
for (Map.Entry<Integer,Student> entry : entrySet){
System.out.println("key值为:"+entry.getKey()+",对应的value值为:"+entry.getValue());
}
System.out.println("--------------------------------------------------------");
// 使用key作为对象
HashMap<Student, Integer> map = new HashMap<>();
map.put(new Student(1,"张三",20,"男"),1);
map.put(new Student(2,"李四",18,"女"),2);
map.put(new Student(3,"王五",22,"男"),3);
// 通过keySet方法获取集合中所有的key值,在通过key值获取集合所有的value值
Set<Student> students = map.keySet();
for (Student student : students) {
System.out.println("key值为:"+student+",对应的value值为:"+map.get(student));
}
}
}
TreeMap
TreeMap:底层实现是红黑二叉树,实现元素排序
案例作业
使用键盘录入输入一个字符串,键作为某个字符串,值作为字符串的个数
// 比如:asdasdaad
// 结果:
// 键=a,值=4
// 键=s,值=2
// 键=d,值=3
public class Test04 {
public static void main(String[] args) {
// 使用键盘录入输入一个字符串,键作为某个字符串,值作为字符串的个数
// 比如:asdasdaad
// 结果:
// 键=a,值=4
// 键=s,值=2
// 键=d,值=3
// 创建一个Scanner对象
Scanner scanner = new Scanner(System.in);
// 提示语句
System.out.println("请输入一个字符串:");
// 接受语句
String next = scanner.next();
// 创建一个HashMap集合,键是字符串,值是字符串出现的次数
HashMap<Character, Integer> map = new HashMap<>();
// 遍历输入字符串中的每个字符串
for (int i = 0; i < next.length(); i++) {
// 取出每个字符
char ch = next.charAt(i);
// 得到每个字符
System.out.print(ch+" ");
// 拿这个字符去HashMap集合中看看有没有这个key,如果有的话就给对应的值+1,没有的话就说明这个字符串还是
// 第一次统计,就直接存进去
if (map.containsKey(ch)){
// 有的话就给对应的值+1
map.put(ch,map.get(ch)+1);
}else {
// 没有就直接存进去
map.put(ch,1);
}
}
System.out.println("\n键:"+map.keySet()+",值:"+map.values());
}
}