集合
目录
-
概念:对象的容器,存储对象的对象,可代替数据
-
特点:容器的工具类,定义了对多个对象进行操作的常用方法
-
位置:java.util.*;
一.Collectio(父接口)
-
特点:代表一组任意类型的对象,无序,无下标
-
方法
-
boolean add(OBject obj)//添加一个对象
-
boolean addAll(Collection c)//将一个集合中所有对象添加到集合中
-
void clear()//清空此集合中的所有对象
-
boolean contains(Object o)//检查此集合中是否包含o对象
-
boolean equals(Object o)//比较此集合是否与指定对象相等
-
Boolean isempty()//判断集合是否为空
-
boolean remove(Object o)//在此集合中移除o对象
-
int size()//返回此集合中的元素个数
-
Object[] toArray()//此集合中转换成数组
二.List子接口
二.1.List集合
-
是Collection集合的子类
-
特点:有序,有下标,元素可以重复
-
方法:
-
void add(int index,Object o)//在index位置插入对象o
-
boolean addAll(int index,Collection c)//将集合中一个元素添加到
-
//此集合中的Inde位置
-
Object get(int index)//返回集合中指定位置的元素
-
List subList(int fromIndex,int toIndex)//返回formIndex和toIndeX之间的元素
List实现类:
-
ArrayList重点:
-
jdk7之前创造无参构造方法,初始值为10 * jdk8创造无参构造方法,初始值为0,如果不用,不占空间,当插入元素之后为10,数组扩容,降低内存的使用
package LIst;
import java.util.ArrayList;
class AList {
/**
* jdk7之前创造无参构造方法,初始值为10
* jdk8创造无参构造方法,初始值为0,如果不用,不占空间,当插入元素之后为10
* @param args
*/
public static void main(String[] args){
ArrayList al =new ArrayList();
boolean result = al.add("Hello");//对象的容量存储对象的对象
System.out.println(result);//存储到下标为0的数组里面
Object obj= al.get(0);//将底层object下标的0的元素返回
System.out.println(obj);
al.add("A");
al.add("B");
al.add("C");
al.add("D");
for (int i = 0; i <al.size() ; i++) {
System.out.println(al.get(i));//get方法基于下标获取元素
}
System.out.println(al.toString());//[Hello, A, B, C, D]
//al.clear();//清空
System.out.println(al.isEmpty());//是否为空
// al.remove("D");//移除某个对象
// System.out.println(al.toString());//[Hello, A, B, C]
boolean remove =al.remove("D");
Object removeoj =al.remove(1);
System.out.println(removeoj);//A 移除后得到的数字下标的内容
}
}-
数组结构实现:查询快,增删慢,必须开辟连续空间
-
jdk1.2版本,执行效率快,线程不安全
Vector类.
-
数组结构实现:查询快,增删慢
-
jdk1.0版本,运行效率慢,线程安全
LinkedList类.
-
.链表结构:增删快,查询慢,无需开辟连续空间
package LIst;
import java.util.List;
public class LinkedList {
public static void main(String[] args) {
List linkedList =new java.util.LinkedList();
linkedList.add("a");
linkedList.add("b");
linkedList.add("c");
linkedList.add("d");
for (int i = 0; i <linkedList.size() ; i++) {
System.out.println(linkedList.get(i));
}
System.out.println(linkedList.toString());
linkedList.remove(1);
linkedList.size();
linkedList.set(2,"F");//修改
System.out.println(linkedList.toString());
}
}
泛型集合[解决应用问题]
-
概念:参数化类型,类型安全的集合,强制集合元素的类型必须
-
特点:编译即可检查,而非运行时抛出异常
-
访问时,不必类型转换
-
要求前后类型一致
-
不同泛型之间引用不能相互赋值,泛型不存在多态
泛型:高级类别的知识
概念:约束,规范类型
泛型的场景:
实例泛型:创建对象时,为类定义的泛型,进行参数化赋值
静态泛型:比较数据
三.Set子接口
三.1.Set集合
特点:无序,无下标,元素不能重复(当插入新元素,如果新元素与已有元素进行equals比较,结果true,则拒绝新元素的插入)
方法:全部继承Collection中的方法
HashSet
-
底层是HashMap.即是所有需要存入HashSet的值,直接保存在HashMap中
-
package Set;
import java.time.Instant;
import java.util.HashSet;
import java.util.Set;
public class HashSet01 {
public static void main(String[] args) {
//Set实现类,所有元素不可重复
Set<Integer> number = new HashSet<Integer>();
number.add(22);
number.add(23);
number.add(24);
number.add(25);
number.add(26);
number.add(6);
number.add(26);//插入成功被覆盖?还是过滤掉//
number.add(16);
number.add(36);
System.out.println(number.add(11));
for (Integer num:number) {
System.out.print(num+"\t");
}
System.out.println();//16 36 22 6 23 24 25 26 11
}
}
-
HashSet如何去重?去掉了重复equals-->Object提供的equlal方法,内部使用this==obj进行判断
-
HashSet:
-
基于HashCode实现元素不重复,
-
当存入元素的哈希吗相同时,会调用equals进行比较,如果为true,拒绝插入
-
先判断哈希值是否一样,==比较地址,equals比较内容
package Set;
import java.util.HashSet;
import java.util.Set;
public class HashSetQuZhong {
public static void main(String[] args) {
Student student1 = new Student("ton", 19, "man", 99.0);//0*000011
Student student2 = new Student("jon", 29, "man", 99.0);
Student student3 = new Student("son", 39, "man", 99.0);
Student student4 = new Student("lon", 49, "man", 99.0);
Student student5 = new Student("lon", 49, "man", 99.0);//0*000022
Set<Student> studentSet = new HashSet<Student>();//ctrl+shift+o导包
studentSet.add(student1);//0*000011
studentSet.add(student2);
studentSet.add(student3);
studentSet.add(student4);
studentSet.add(student1);//0*000011,去掉重复,调用equals-->Object提供的equals方法,内部使用this==obj惊醒方法
studentSet.add(student5);//地址不一样.内容重复
for (Student stu : studentSet) {
System.out.println(stu.toString());
}
//HashSet没有必要插入新数据没有必要与已有的数据进行一一比较
//HashSet原有equals方法进行比较,是具有前提的(俩个对象的哈希值是相同的)
System.out.println(student4.equals(student5));//true
System.out.println(student4.hashCode());
System.out.println(student5.hashCode());
}
}
class Student {
String name;
Integer age;
String sex;
Double score;
public Student() {
}
public Student(String name, Integer age, String sex, Double score) {
this.name = name;
this.age = age;
this.sex = sex;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
", score=" + score +
'}';
}
@Override
public boolean equals(Object object){
if (this == object) {
return true;
}
if (object == null) {//对象为空
return false;
}
if (this.getClass() != object.getClass()) {//类型不一样
return false;
}
Student s =(Student)object;
if(this.name.equals(s.name)&&this.age.equals(s.age)&&this.sex.equals(s.sex)&&this.score.equals(s.score)){
return true;
}
return false;
}
//hashCode才是调用equals的前提
//只有哈希码相同,才能用equals
public int hashCode(){
return 123;
}
}
/*
Student{name='ton', age=19, sex=man, score=99.0}
Student{name='jon', age=29, sex=man, score=99.0}
Student{name='son', age=39, sex=man, score=99.0}
Student{name='lon', age=49, sex=man, score=99.0}
true
123
123
*/
LinkedHashSet:
-
链表实现的HashSet,按照链表进行存储,即可保留元素的插入顺序
-
底层使用linkedHashMap存储,节点形式完成单独数据的保存,并可以指向下一个节点,通过顺序访问节点,可保留插入顺序
package Set;
import java.util.LinkedHashSet;
public class LinkedHashSetTest {
public static void main(String[] args) {
//LinkedHashSet底层使用linkedHashMap链表结构,节点形式完成单独数据的保存,并可以指向下一个节点,通过顺序访问节点,可以保留元素插入顺序
LinkedHashSet<String> linkedHashSet =new LinkedHashSet<String>();
linkedHashSet.add("A");
linkedHashSet.add("a");
linkedHashSet.add("B");
linkedHashSet.add("b");
for (String set: linkedHashSet) {
System.out.print(set+"\t");
}
System.out.println();
LinkedHashSet<Integer> linkedHashSet1 =new LinkedHashSet<Integer>();
linkedHashSet1.add(28);
linkedHashSet1.add(11);
linkedHashSet1.add(44);
linkedHashSet1.add(11);
for (Integer set1: linkedHashSet1) {
System.out.print(set1+"\t");
}
System.out.println();
}
}
/*
A a B b
28 11 44
*/TreeSet:
-
基于排列顺序实现元素不重复
package Set;
import com.sun.org.apache.xml.internal.serializer.TransformStateSetter;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Integer> treeSet =new TreeSet<>();//自动排序,调用一组对象的compareTo方法,返回值为0位重复元素
treeSet.add(3);
treeSet.add(2);
treeSet.add(1);
treeSet.add(10);
System.out.println(treeSet.add(3));//false
for (Integer tree: treeSet) {
System.out.print(tree+"\t");
}
System.out.println();
}
}
//false
1 2 3 10 -
实现SortedSet接口,对集合元素自动排序
-
元素对象的类型必须实现Comparable接口,指定排序规则
-
通过CompareTo确定是否为重复元素 返回值为0
package Set;
import java.util.TreeSet;
public class TreeCompareTest {
public static void main(String[] args) {
TreeSet<Stu>treeSet =new TreeSet<>();
treeSet.add(new Stu("ton",22));
treeSet.add(new Stu("son",32));
treeSet.add( new Stu("lon",12));
treeSet.add( new Stu("jon",2));
treeSet.add( new Stu("jeon",22));
System.out.println(treeSet.size());//1
for (Stu s:
treeSet ) {
System.out.println(s.name);//ton
System.out.print(s+"\t");//2 12 22 32
}
}
}
class Stu implements Comparable<Stu>{
String name;
Integer age;
public Stu(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Stu o) {
System.out.println("Compare被Tree回调");
//升序
if (this.age <o.age ) {//比this小,this就要靠前
return -1;
}else if(this.age>o.age){//比this大,this就要靠后
return 1;
}
return 0;//结果一样,代表去重
}
// @Override
// public int compareTo(Stu o) {
// System.out.println("Compare被Tree回调");
// //降序
// if (this.age <o.age ) {//比this小,this就要靠前
// return 1;
// }else if(this.age>o.age){//比this大,this就要靠后
// return -1;
// }
// return 0;//结果一样,代表去重
// }
}四.遍历
package CollectionBianLi;
//迭代器专注collection接口的集合
import java.util.*;
public class TestIterator {
public static void main(String[] args) {
//对Collection体系集合进行遍历
List<String> list =new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");
//1.获得一个迭代器
//hasNext():是否有下一个元素遍历 有 true,没有:false
//next(); 返回下一个元素
Iterator<String> iterator =list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
Set<String> set =new HashSet<>();
set.add("e");
set.add("f");
set.add("r");
set.add("w");
set.add("a");
Iterator<String> iterator1 =set.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
/*
A
B
C
D
E
a
r
e
f
wMap集合体系
一.Map接口
特点.
-
用于存储任意键值对(Key-Value)
-
键:无序,无下标,不予许重复(唯一)
-
值:无序.无下标,允许重复
方法.
-
V put(K key,V value)//将对象存入到集合,关联键值,Key重复则覆盖原值
-
Object get(Object key)//根据键获取对应的值
-
Set<K> keySet()//返回所有Key
-
Collcetion<V> values()//返回包含所有值的Collcetion集合
-
Set<Map,Entry<K,V>>//键值匹配的Set集合
二.HashMap
算法:拿到任何一个对象,通过hash(key)做运算:key>>>16(除以16),其可能得到0-15之间一个的数字,作为插入数组的下标
-
jdk1.2版本,线程安全,运行效率快,允许用null作为Key或者value
package Map; import java.util.HashMap; public class TestBasicHashMap { public static void main(String[] args) { HashMap<Integer,String> map = new HashMap(); map.put(1,"中国"); map.put(2,"美国"); map.put(3,"英国"); map.put(1,"中国666"); String country=map.get(1); System.out.println(country);//重复的key进行覆盖 //中国666 } }
三.Hashtable
-
jdk1.0版本,线程安全,运行效率慢,不予许用null作为key或者value
四.Properties
-
Hashtable的子类,要求key或者value都是String,通常用于配置文件的读取
五.TreeMap.
-
实现了SortedMap接口(是Map的子接口),可以对Key自动排序,是Tree的底层
-
六.遍历
package Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapTest02 {
public static void main(String[] args) {
Map<Integer,String> map= new HashMap<Integer, String>();
map.put(1,"China");
map.put(2,"japan");
map.put(3,"Asia");
map.put(4,"Lisa");
//遍历方法,keySet
Set Keys =map.keySet();
for (Object k:Keys) {
System.out.println(k);//获得所有的键
System.out.println(map.get(k));//获得所有的值
}
//遍历方式2 values(); 获得值
Collection<String> cs = map.values();
for (String value:cs){
System.out.println(value);//获得所有的值
}
//entrySet();键值对
//Set集合存储的都是node getKey(), getValue
Set<Map.Entry<Integer,String>> entry =map.entrySet();
for (Map.Entry<Integer,String> e:entry) {
System.out.println(e.getKey()+":"+e.getValue());//拿到的是键值对的对象
}
}
}
扫一扫
2825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
