集合process2

1、集合概念

定义：对象的容器，定义了多个对象进行操作方法。类似于数组的功能

和数组的区别：

数组长度固定，集合长度不固定
数据存储基本类型也有引用类型，集合只能存储引用类型（可以通过装箱存储基本类型）

位置：java.util.*;

2、collection体系集合

List接口-有序，有下标，元素可重复

实现类：ArrayList , LinkeList , Vector
Set接口-无序，无下标，元素不可重复

实现类：HashSet , SortedSet(接口）-TreeSet（类）

注意：接口不能实例化

2.1Collection接口的使用

特点：代表一组任意类型的对象，无序，无下标，元素不可重复

常用方法：

add(Object obj);添加一个对象
addAll(Collection c);将一个集合中的所有对象添加到此集合中
clear();清空此集合中的所有对象
contains(Object o);检查此集合中是否包含o对象

iterator();返回在Collection元素上进行迭代的迭代器

hashNext();判断有没有下一个元素，next();获取下一个元素，remove();删除当前元素

Collection接口的使用1：保存字符串

添加元素
判断
遍历元素
删除元素
```
package collec;
public class Demo1 
```

Collection接口的使用2：保存学生信息

添加数据
判断
遍历元素

删除

package collec;
public class Demo2 

package collec;
public class Student

2.2List接口

2.2.1List定义和方法

List接口-有序（添加顺序和获取顺序一致的），有下标，元素可重复

实现类：ArrayList , LinkeList , Vector

方法：

collection的方法加
1. get();获取 System.out.println(list.get(i));
2. ListIterator（）；从前往后
  hasPrevious()；previousIndex()；从后往前
3. indexOf();查找

List-字符串类型
1. 添加数据
2. 判断
3. 使用for遍历
  使用增强for
  使用迭代器
  
  使用ListIterator（）；行列遍历-特有（纯数据类型没有）（功能更强大，可以向前、向后遍历，添加、删除元素）
  
  hasNext()；nextIndex()；从前往后
  hasPrevious()；previousIndex()；从后往前
4. 删除
5. indexOf();查找
```
package list;
public class Demo1 
```
List-数字类型（注意：集合不能包含基本类型，在添加数字的时候包含了自动装箱操作）

补充方法-subList();返回子集合
1. 添加数据
2. 判断
3. 遍历元素
4. 删除
5. subList();返回子集合
```
package list;
public class Demo2

//2.补充方法subList();返回子集合
List sublist = list.subList(2,4);//2包含，4不包含

//3.删除-有区别（remove是角标）
list.remove(1);
```

2.2.2List实现类

实现类：

ArrayList -数组结构实现，查询快、增删慢，效率快、线程不安全

Vector -数组结构实现，查询快、增删慢，效率慢、线程安全

LinkedList -链表结构实现，查询慢、增删快

2.2.2.1ArrayList使用

ArrayList -数组结构实现，查询快、增删慢，效率快、线程不安全

collection.remove(new Student("yiyi",18));这样写不行d

点开源码，发现是equals();方法，进行方法重写（五大步）

比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用类型指向的实际对象是否一致
强制类型转换

依次比较各个属性值是否相同

package collec;
//Control+O重写父类方法
public class Student 
  
    @Override
    public boolean equals(Object obj) {
        //1.比较两个引用是否指向同一个对象
        if (this == obj) {
            return true;
        }
        //2.判断obj是否为null
        else if (obj == null) {
            return true;
        }
        //3.判断两个引用类型指向的实际对象是否一致
        else {
            if (obj instanceof Student) {//4.强制类型转换
                Student s = (Student)obj;
                //5.依次比较各个属性值是否相同
                if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                    return true;
                }
            }
            return false;
        }

代码步骤

添加数据
判断
遍历元素
删除
indexOf();查找
```
package list;
public class Demo3
```

分析源码实现过程-去看懂源码的操作（以后自己模仿代码）-目前先学会用
1. 默认容量大小 DEFAULT_CAPACITY = 10;
  
  没有向集合中添加任何元素时，容量为0
2. 存放元素的数组 elementDate
3. 存放容量为空 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
4. 实际的元素个数 size
5. 添加元素 add
```
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
```

2.2.2.2Vector实现类

Vector -数组结构实现，查询快、增删慢，效率慢、线程安全

使用频率没有ArrayList高

添加数据
判断
Enumeration en =vector.elements();枚举器遍历
Vector其他方法

firstElement,lastElement,elementAt()
删除

package list;
public class demoV1

2.2.2.3LinkedList实现类

LinkedList -链表结构实现，查询慢、d增删快

存储结构是一个双向链表

添加数据

元素内容可以相同，删和查找都先前面的
判断
使用for遍历
使用增强for
使用迭代器

使用ListIterator（）；行列遍历-特有（功能更强大，可以向前、向后遍历，添加、删除元素）

hasNext()；nextIndex()；从前往后
hasPrevious()；previousIndex()；从后往前
查找
删除

package list;
public class demoL1

2.2.2.4ArrayList和LinkedList的区别

不同结构实现方式：

ArrayList：必须开辟连续空间，查询快（有脚标，可以直接定位），增删慢

LinkedList：无须开辟连续空间，查询慢，增删快

2.3泛型

本质：是参数化类型，将类型作为参数传递
常见形式：有泛型类，泛型接口和泛型方法
方法：

<X....>，X 表示类型占位符，表示一种引用类型(不能是基本类型），多个用，隔开
好处：
1. 提高代码的重用性
2. 防止类型转换异常，提高代码的安全性
注意：1.泛型类型只能是引用类型，2.不同类型不能相互复制

2.3.1泛型类

在类后面

创建变量

注意T不能new构造因为T是数据类型，到底什么类型不知道
泛型作为方法的参数

泛型作为方法的返回值

package mygeneric;
public class Demo1<T>

2.3.2泛型接口

也是在接口和类后面

创建变量

注意T不能new构造，因为T是数据类型，到底什么类型不知道
接口要单独写一个实现类

package mygeneric;
public interface Demo2 <T>

package mygeneric;
//接口要单独写一个实现类
public class Demo2_2 implements Demo2<String>

package mygeneric;
//独写一个实现类时，一开始不定义类型
public class Demo2_3<T> implements Demo2<T>

2.3.3泛型方法

方法返回类型前面（只能用在该方法里面）——提高代码的重用性

package mygeneric;
public class Demo3

2.3.4泛型集合

默认Object类型（父类——所有类型都可以传递）

添加类型后，不用强制转换，使用更安全
特点：
1. 编译时可检查，根据异常判断
2. 访问时，不需要类型转换（拆箱）
3. 不同泛型不能相互复制（不存在多态）

package mygeneric;
public class Demo4

2.4Set接口-会排序

Set接口-无序，无下标，元素不可重复

实现类：HashSet , SortedSet(接口）-TreeSet（类）

2.4.1Set接口的使用

继承collection接口

添加元素
判断
遍历元素
删除元素

Set接口-无序，无下标，元素不可重复

package set;
public class Demo1

2.4.2HashSet实现类

基于HashCode计算元素存放位置

存储结构：哈希表（数组+链表+红黑树（又叫二叉树））

当存放元素的哈希码相同时，调用equals匹配，如果结果为true，则拒绝后者加入

添加元素
判断
遍历元素
删除元素
```
package set;
public class Demo2
```

特点：

添加元素

不能相同类型再添加但是可以person.add(new Person("yiy",33));
判断
遍历元素
删除元素

person.remove(new Person("erer",34));删不掉，要重写方法（HashCode和Equals ）

package set;
public class Demo3

2.4.3TreeSet实现类

基于排列顺序实现元素不重复
实现了SortedSet接口，对集合元素自动排序
元素类象的类型必须实现Comparable接口，指定顺序规则
通过CompareTo方法确定是否为重复元素
1. 添加元素
2. 判断
3. 遍历元素
4. 删除元素

package set;
public class Deno4

TreeSet保存数据-具体的排列方式（二叉）

添加元素

treSet的红黑树没有Compare的对象，在compared写一个比较规则,重写ComparedTo,当返回值为0则为重复元素

package set;
public class Person implements Comparable<Person>

    @Override
    public int compareTo(Person o) {
        //先比姓名，再比年龄
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.getAge();
        return n1==0?n2:n1;
    }

判断
遍历元素
删除元素

person.remove(new Person("erer",34));

package set;
public class Demo5

2.4.4TreeSet实现类的Comparator接口（实现定制比较）

Comparator接口（实现定制比较）
Comparable：可比较的（有参数可以选择）

代码有点不同寻常-创建集合,并指定比较规则

package set;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo6 {
    public static void main(String[] args) {
        //创建集合,并指定比较规则
        TreeSet<Person> person = new TreeSet<>(new Comparator<Person>(){

            @Override
            public int compare(Person o1, Person o2) {
                int n1=o1.getAge()-o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n1==0?n1:n2;
            }
        });
    }
}

2.4.5TreeSet案例

使用TreeSet集合实现字符串按照长度进行排序

yiyi xiaobai hongtaiyang yanzi

package set;
public class Demo7

3、Map<K,V>集合

HashMap类， SortedMap接口—TreeMaple类

特点:

用于存储任意键值对（Key-Value）
键：无序、无下标、不允许重复（唯一）
值：无序、无下标、允许重复

方法：

put(K Key,V Value);将对象存入到集合中，关联键值。key重复则覆盖原值
get(Object key);根据键获取对应的值
KeySet(K);返回所有key
Collectionvalues();返回包含所有值得Collection集合
Set<Map.Entry<K,V>>键值匹配得Set集合

3.1Map<K,V>的使用

添加元素

使用put(K，V);

m.put("cn","中国");
m.put("cn","zhongguo");//其中第一个（默认为键值）相同，加不进去

判断
遍历元素

3.1使用 keySet();再使用增强 for

3.2使用 entrySet();方法，效率更高

删除元素

读键值位置

m.remove("cn");//其中键值元素，即可删除
System.out.println(m.toString());

package map;
public class Demo1

3.2HashMap的使用

存储结构——哈希表（数组+链表+红黑树）

添加元素

使用put(K，V);

加入重复键值内容

s.put(new Student("sansan",23),"宜宾");//这样可以加入重复键值内容或者新内容（不需要重写方法）

打印的排序是倒序和强加

判断
遍历元素

3.1使用 keySet();再使用增强 for

3.2使用 entrySet();方法，效率更高
删除元素

package map;
public class Demo2

3.2.1Hashtable和Properties

HashMap：线程不安全，运行效率快；允许null作为Key或是Value
Hashtable（用的不多）：线程安全，运行效率慢；不允许null作为Key或是Value

Properties（常用的Hashtable的子类）：（常用的Hashtable的子类）要求key和value都是String。通常用于配置文件的读取
TreeMap（红黑树排列）：实现了SortedMap接口（是Map的子接口），可以对key自动排序

3.3TreeMap的使用

TreeMap（红黑树排列）：实现了SortedMap接口（是Map的子接口），可以对key自动排序

添加元素

使用put(K，V);

加入重复键值内容

s.put(new Student("sansan",23),"宜宾");//这样可以加入重复键值内容或者新内容（不需要重写方法）

红黑树排列，定制比较，需要重写Comparable方法，否则会报错

public class Student implements Comparable<Student> 
//先比年龄，后比姓名
    @Override
    public int compareTo(Student o) {
        int n2 = this.age-o.getAge();
        int n1 = this.name.compareTo(o.getName());
        return n1==0?n2:n1;
    }

判断
遍历元素

3.1使用 keySet();再使用增强 for

3.2使用 entrySet();方法，效率更高
删除元素

package map;
public class Demo3

4、Colletions工具类

概念：集合工具类，定义了除了存取以外的集合常用方法

方法：

reverse(List<> list);反转集合中元素的顺序
shuffle(List<> list);随机重置集合元素的顺序
sort(List<> list);从小到大（元素类型必须实现Comparable接口）
binarySearch()；查找（用在排序之后）——第一个的位置
copy();复制——两个集合的大小应该相同（使用for循环）

list转成数组数组转成list

注意：基本类型数组转为集合时，需要修改为包装类型

//List转成数组-多的为null
System.out.println("======List转成数组=========");
Integer[] arr = list.toArray(new Integer[10]);
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));

//数组转成集合-不允许删除和添加
System.out.println("======数组转成集合=========");
String[] name = {"张三","李四","王五"};
List<String> list2 = Arrays.asList(name);
System.out.println(list2);

//基本类型数组转为集合时，需要修改为包装类型
Integer[] nums = {11,22,33,44,55,66};
List<Integer> list3 = Arrays.asList(nums);
System.out.println(list3);

package collec;
public class Demo4

5、Properties(属性集合)

特点：

存储属性名和属性值
属性名和属性值都是字符串类型
没有泛型
和流有关

使用
1. 创建集合
2. 添加数据
3. 遍历
  
  3.1 keySet
  
  3.2 entrySet
  
  3.3 StringPropertyNames()
4. 和流有关的方法
  1. list（列表）方法
  2. store(保存)方法
  3. load(加载)方法

package properties;
public class Demo1

posted @ 2024-08-08 23:17 37201 阅读(12) 评论(0) 收藏举报

刷新页面返回顶部

集合process2

1、集合概念

2、collection体系集合

2.1Collection接口的使用

2.2List接口

2.2.1List定义和方法

2.2.2List实现类

2.2.2.1ArrayList使用

2.2.2.2Vector实现类

2.2.2.3LinkedList实现类

2.2.2.4ArrayList和LinkedList的区别

2.3泛型

2.3.1泛型类

2.3.2泛型接口

2.3.3泛型方法

2.3.4泛型集合

2.4Set接口-会排序

2.4.1Set接口的使用

2.4.2HashSet实现类

2.4.3TreeSet实现类

2.4.4TreeSet实现类的Comparator接口（实现定制比较）

2.4.5TreeSet案例

3、Map<K,V>集合

3.1Map<K,V>的使用

3.2HashMap的使用

3.2.1Hashtable和Properties

3.3TreeMap的使用

4、Colletions工具类

5、Properties(属性集合)

公告