集合
- 具有相同性质的东西放到一个类似于容器的东西中称为集合
基本的操作有
- 将对象添加到集合中
- 从集合中删除对象
- 从集合中查找对象
- 从集合中修改对象
- 集合和数组的区别
- 数组一旦被定义就无法再被改变长度大小，集合却可以
| 数组 | 集合 | |
|---|---|---|
| 容器 | 是 | 是 |
| 大小 | 一旦被创建后，它的大小就是固定的 | 集合大小是一直可变的 |
| 数据 | 基本数据类型、引用类型 | 引用类型 |
| 类型 | 数组中存储的数据类型是相同的 | 集合中可以存储任意类型的对象 |
集合(集合的框架)
Java集合框架的接口
| 接口 | 特点 |
|---|---|
| Collection | 集合的根接口，没有实现类，用于引用子接口的对象。Collection 是一组对象的集合 |
| List | 元素之间是有序的，元素可以重复。通过引用来访问元素，允许在指定位置插入元素 |
| Set | 元素之间是无序的，元素不可重复。 |
| Map | 存储Key/Value对的集合。key值不允许重复，每个key最多只能映射到一个值。Map是一组Key/Value对的集合 |
实现接口运用实际：
List的特点：
元素有序
元素有下标
元素可重复
遍历时存入顺序和取出顺序一致
- 在实际开发中，ArrayList是使用频率最高的一个集合实现类
- ArrayList的方法使用：
例：
package com.etime;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList arrayList=new ArrayList();
boolean empty = arrayList.isEmpty();
System.out.println(empty);
int size = arrayList.size();
System.out.println(size);
System.out.println("*********************************");
arrayList.add("az");
arrayList.add("ay");
arrayList.add("az");
arrayList.add("yr");
System.out.println(arrayList.get(3));//得到下标为3的元素
System.out.println("*********************************");
for (int i = 0; i < arrayList.size(); i++) {//遍历该集合中的所有元素
System.out.println(arrayList.get(i));
}
System.out.println("*********************************");
empty=arrayList.isEmpty();
System.out.println(empty);//判断当前的集合是否为空
System.out.println("*********************************");
Object remove = arrayList.remove(2);//移除下标为2的元素
System.out.println(remove);
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
empty=arrayList.isEmpty();
System.out.println(empty);
System.out.println("*********************************");
}
}
- 向ArrayList集合中加入Student类的对象数据
- 并且使用迭代器Iterator将集合数组中的元素遍历出来
例：
package com.etime;
import java.util.ArrayList;
import java.util.Iterator;
public class Test2 {
public static void main(String[] args) {
//迭代器看作是遍历集合的接口
ArrayList<Student> arrayList=new ArrayList<>();
arrayList.add(new Student("xx","1165564"));
arrayList.add(new Student("ff","4446586"));
arrayList.add(new Student("nm","541489"));
arrayList.add(new Student("nf","446684"));
//通过For循环的方式把集合中数据遍历出来
for (int i = 0; i < arrayList.size(); i++) {
Student student = arrayList.get(i);
System.out.println(student);
}
System.out.println("**************");
//通过迭代器的方式首先判断集合中是否还有数据，然后调用方法next返回下一个的值
Iterator<Student> iterator= arrayList.iterator();//是实现了iterator接口的类的对象
while (iterator.hasNext()){
Student next = iterator.next();
System.out.println(next);
}
//迭代集合时刻不能同时修改集合内的东西，会报同时修改异常
// Iterator<Student> iterator1=arrayList.iterator();
// while (iterator1.hasNext()){
// Student next = iterator1.next();
// System.out.println(next);
// arrayList.add(new Student("xv","178441"));
// }
//泛型----广泛（规范）类型
//例子：作为ArrayList集合对象的相同类
ArrayList<Student> arrayList2=new ArrayList<>();
//该arrayList2集合中只能是存放Student类对象的数据，不被允许放入其它类型的数据，规范性
//如果没有限定泛型的情况下，则可以向定义了的集合中添加任何元素，但是找出元素时会出现不符合当前类型的数据无法被取出
ArrayList arrayList1=new ArrayList();
arrayList1.add("xd");
arrayList1.add(new Student("xi","5416586"));
arrayList1.add(3);
for (int i = 0; i < arrayList1.size(); i++) {
Student o = (Student) arrayList1.get(i);/**Exception in thread "main" java.lang.
强制转换输出该类对象，输出错误 ClassCastException: java.lang.String cannot
be cast to com.etime.Student
*/
System.out.println(o);
}
}
}
- 创建一个类，该类中设置有属性基本数据类型整型，找出所有创建类对象中集合里该属性的最大值是多少
例：
package com.etime;
public class Student {
private String name;
private String nums;
public Student() {
}
public Student(String name, String nums) {
this.name = name;
this.nums = nums;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNums() {
return nums;
}
public void setNums(String nums) {
this.nums = nums;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", nums='" + nums + '\'' +
'}';
}
}
package com.etime;
import java.util.ArrayList;
import java.util.Iterator;
public class Test3 {
public static void main(String[] args) {
//查找集合中的数大小
ArrayList<Person> arrayList=new ArrayList<>();
arrayList.add(new Person("xm",20,"男"));
arrayList.add(new Person("nc",54,"男"));
arrayList.add(new Person("nb",25,"女"));
System.out.println("**************");
int maxAge=arrayList.get(0).getAge();
for (int i = 0; i < arrayList.size(); i++) {
if (arrayList.get(i).getAge()>maxAge){
maxAge=arrayList.get(i).getAge();
}
}
System.out.println(maxAge);
System.out.println("*******************");
Iterator<Person> iterator=arrayList.iterator();
int maxAge1=arrayList.get(0).getAge();
while (iterator.hasNext()){
int age = iterator.next().getAge();
if (maxAge1<age){
maxAge1=age;
}
}
System.out.println(maxAge1);
// System.out.println("********************");
// iterator.hasNext();
// System.out.println(iterator.next());
// iterator.hasNext();
// System.out.println(iterator.next());
// iterator.hasNext();
// System.out.println(iterator.next());
}
}
Set
Set中元素是无序存放的，即元素存入和取出的顺序不一样，并且集合中元素不能重复。其中，HashSet是一种常用的Set
Set的特点：
Set中的元素无序，但可以排序
Set中的元素无下标
Set中的元素不可重复
HashSet
- 只有不相同的情况下才能满足该元素能被存入该数集合当中
- hashCode()方法得到一个哈希值，然后在集合中查找是否有哈希值相同的对象，如果没有哈希值相同的对象就直接存入集合内，如果有哈希值相同的对象，就和哈希值相同的对象进行equals比较，比较结果为false则存入，为true则不存入
例：
package com.etime;
import java.util.Objects;
public class Person implements Comparable<Person>{
private String name;
private int age;
private String gender;
public Person() {
}
public Person(String name, int age, String gender){
this.name = name;
this.age = age;
this.gender = gender;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name) && Objects.equals(gender, person.gender);
}
@Override
public int hashCode() {
return Objects.hash(name, age, gender);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
@Override
public int compareTo(Person o) {
if (this.age>o.getAge()){
return 1;
}else if (this.age<o.age){
return -1;
}else{
return this.name.compareTo(o.name);
}
}
}
package com.etime;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest {
public static void main(String[] args) {
HashSet<Person> hashSet=new HashSet<>();
Person p1=new Person("xi",45,"男");
Person p2=new Person("xix",45,"男");
Person p3=new Person("xig",45,"男");
Person p4=new Person("xir",45,"女");
Person p5=new Person("xie",45,"男");
Person p6=new Person("xi",45,"男");
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
hashSet.add(p4);
hashSet.add(p5);
hashSet.add(p6);
System.out.println(hashSet.size());//hashSet.size()的结果为5，可见hashSet只能存不相同数据
System.out.println("*************");
hashSet.remove(p3);
int size = hashSet.size();
System.out.println(size);
boolean empty = hashSet.isEmpty();
System.out.println(empty);
System.out.println("*************");
Iterator<Person> iterator= hashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("*************");
System.out.println(hashSet.isEmpty());
System.out.println(hashSet.size());
System.out.println(p1.equals(p6));//注意该地方如果在没有对象类中重写过Object中的hashCode 和
// Equals时，比较的仍然和“==”相同
}
}
TreeSet
- TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式
- 要求数据元素不能够重复储存，并对数据进行排序
- 排序接口使用Comparable
- 实现该接口中的方法comparableTo()方法
- 所有加入TreeSet的元素必须实现Comparable接口，否则会抛出异常，在TreeSet内部使用Comparable接口对元素排序。和HashSet相比，它的效率比较低
例：
package com.etime;
import java.util.Objects;
public class Person implements Comparable<Person>{
private String name;
private int age;
private String gender;
public Person() {
}
public Person(String name, int age, String gender){
this.name = name;
this.age = age;
this.gender = gender;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name) && Objects.equals(gender, person.gender);
}
@Override
public int hashCode() {
return Objects.hash(name, age, gender);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
@Override
public int compareTo(Person o) {
if (this.age>o.getAge()){
return 1;
}else if (this.age<o.age){
return -1;
}else{
return this.name.compareTo(o.name);
}
}
}
package com.etime;
import java.util.Iterator;
import java.util.TreeSet;
public class TestTreeSet {
public static void main(String[] args) {
TreeSet<Person> personTreeSet=new TreeSet<>();
Person p1=new Person("zh",34,"男");
Person p2=new Person("hh",20,"女");
Person p3=new Person("zz",25,"男");
Person p4=new Person("mh",19,"女");
Person p5=new Person("zc",34,"男");
personTreeSet.add(p1);
personTreeSet.add(p2);
personTreeSet.add(p3);
personTreeSet.add(p4);
personTreeSet.add(p5);
//由上如果需要添加成功，那在该实现接口中的TreeSet中需要先规定如何排序数据，才能添加成功。
// 用添加类继承Compareable接口并实现该接口中的方法compareTo(该方法中规定以什么样的规则对数据进行排序)
Iterator<Person> iterator = personTreeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
Map
- 在集合框架中，Map与Collection是并列存在的，互相没有继承关系
- Map的特点：
- 采用key/value的形式存储数据
- Map中key不可重复
- 各个键值对无序
- 各个键值对无下标
HashMap
- HashMap是使用最广泛的Map实现，它的底层是哈希表数据结构实现存储，不支持多线程同步，可以存入null键，null值、
例：
package com.etime;
import java.util.*;
public class TestMap {
public static void main(String[] args) {
HashMap<String,String> hashMap=new HashMap<>();
hashMap.put("四川","成都");
hashMap.put("云南","昆明");
hashMap.put("贵州","贵阳");
hashMap.put("重庆","重庆");
hashMap.put("新疆","乌鲁木齐");
//根据键获取值
System.out.println(hashMap.get("贵州"));
//判断键和值是否存在该集合当中
System.out.println(hashMap.containsKey("重庆"));
System.out.println(hashMap.containsValue("大理"));
System.out.println(hashMap.isEmpty());
System.out.println(hashMap.size());
//根据键移除数据
System.out.println(hashMap.remove("重庆"));
Set<String> strings = hashMap.keySet();
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()){
String key = iterator.next();
String value = hashMap.get(key);
System.out.println(key+" "+value);
}
System.out.println("************************");
//HashMap的遍历二
Set<Map.Entry<String, String>> entries = hashMap.entrySet();
Iterator<Map.Entry<String, String>> iterator1 = entries.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
erator = strings.iterator();
while (iterator.hasNext()){
String key = iterator.next();
String value = hashMap.get(key);
System.out.println(key+" "+value);
}
System.out.println("************************");
//HashMap的遍历二
Set<Map.Entry<String, String>> entries = hashMap.entrySet();
Iterator<Map.Entry<String, String>> iterator1 = entries.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
6900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
