集合框架的操作使用

Hu_下笔

已于 2022-04-20 11:41:49 修改

阅读量519

点赞数

分类专栏： java学习文章标签： java

于 2022-04-16 11:03:19 首次发布

本文链接：https://blog.csdn.net/weixin_51747082/article/details/124208658

版权

java学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

集合框架的概述

可以将集合框架作为数组来进行理解

java官方就基于数组，根据不同的数据结构，封装出来了很多的类，这些类统称为：集合框架。

1.List表格

1.1 List表格的特点

用户可以精确控制列表中每个元素的插入位置

用户可以通过列表中的位置访问元素，并搜索列表中的元素

常用的增删改查的方法

可以简单的理解成和数组的使用方式差不多

1.2 ArrayList 创建数组

（1）先调用类

import java.util.ArrayList;
import java.util.List;

（2）创建ArrayList

1.默认容量ArrayList

public static void main(String[] args) {
        List  list =  new ArrayList();

｝

2.自定义初始容量List

public static void main(String[] args) {
        List  list =  new ArrayList(6);

｝

1.3 ArrayList添加数据

（1）变量名.add("数据内容")

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.add("java01");
}

（2）变量名.add(数据要添加的下标位置，"数据内容")

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.add("java01");
        list.add(3,"java002");
}

1.4 ArrayList删除数据（数据自动向前移位）

（1）删除list中 “数据” #变量名.remove("数据内容")

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.remove("java01");
    
}

（2）删除特定位置下标内容 #变量名.remove(下标位置)


package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.remove(2);
    
}

（3）删除内容后返回值为删除的结果


package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        boolean remove = list.remove("java01");
    
}

1.5 ArrayList修改数据

（1）对文件先删除在添加 #变量名.set(下标位置，"修改内容")


package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.set(2."java02");
    
}

1.6 ArrayList查询数据

（1）查询所有的集合数 #int 变量名 = 变量名.size();

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.add("java01");
        int size = list.size()
}

（2）get方法查询下标 #Object 变量名 = 变量名.get(下标位置)

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.add("java01");
        Object a = list.get(1)
}

（3）出现的首末位置没有返回-1

首次内容出现的下标位置： int 变量名 = 变量名.indexOf("内容");
最后出现内容的下标位置： int 变量名 = 变量名.lastIndexOf("内容");

（4）for循环和for-each

package com.Text;

import java.util.ArrayList;
import java.util.List;

public class java001 {
    public static void main(String[] args) {
        List  list =  new ArrayList();
        list.add("java01");
        

        for (int i = 0; i < list.size(); i++) {
            Object a1 = list.get(i);
            System.out.println(a1);
        }

        for (Object a2 :list){
            System.out.println(a2);
        }
}

1.7 ArrayList底层原理

也就是说 ArrayList的底层就是一个 Object 类型的数组 用变量 elementData

2.LinkedList

2.1 LinkedList和ArrayList的区别

ArrayList 底层体现出来的数据结构是数组
Linkedlist 底层体现出来的数据结构是链表

2.2 LinkedList的创建

导入包 import java.util.LinkedList;

LinkedList 变量名 = new LinkedList();

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
        
}

2.3 Linkedlis的添加

（1）变量名.add("数据内容")

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add("张三");
        
}

（2）变量名.add(数据要添加的下标位置，"数据内容")

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
        
}

2.4 Linkedlis的删除

（1）删除“数据” #变量名.remove("数据内容")

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
             linkedList.remove("张三");
        
}

（2）删除特定位置下标内容 #变量名.remove(下标位置)

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
             linkedList.remove(2);
        
}

2.5 Linkedlis的修改

（1）对文件先删除在添加 #变量名.set(下标位置，"修改内容")

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
             linkedList.set(2，"李四");
        
}

2.6 Linkedlis的查询

（1）查询所有的链表数 #int 变量名 = 变量名.size();

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
               int size = linkedList.size();
        
}

（2）get方法查询下标 #Object 变量名 = 变量名.get(下标位置)

package com.Text;

import java.util.LinkedList;

public class java002 {
    public static void main(String[] args) {
        LinkedList  linkedList =  new LinkedList();
             linkedList.add(2，"张三");
               int size = linkedList.size();
        
}

2.7 Linkedlis的底层原理

当我们创建 LinkedList haha = new LinkedList();

创建了一个对象

由（上一个节点对象类数据下一个节点对象类）构成

Set 是无序且不能重复的，是一个结构（无序：不按照录入顺序排列并且没有下标）

3.HashSet 注意：没有查询

3.1 创建HashSet对象。默认初始容器大小为（16）70%时要求扩容

public class Test {
    public static void main(String[] args) {
        HashSet  hashSet= new HashSet();
        HashSet  hashSet1 = new HashSet(16);//初始容器的大小
    }
}

变量名.add("内容")

（1）变量名.add("内容")

（2）变量名.addAll(变量名)

public class Test {
    public static void main(String[] args) {
        HashSet  hashSet= new HashSet();
        HashSet  hashSet1 = new HashSet(16);//初始容器的大小
        hashSet.add("java01");
        hashSet.add("java02");
        
        HashSet set2=new HashSet();
        set2.add("刘德华");
        
        hashSet.addAll(set2); 
    }
}

3.2 删除HashSet对象

hashSet.remove("内容");
hashSet.clear();//清空容器集合

public class Test {
    public static void main(String[] args) {
        HashSet  hashSet= new HashSet();
        HashSet  hashSet1 = new HashSet(16);//初始容器的大小
        hashSet.add("java01");
        hashSet.add("java02");
        
         hashSet.remove("java01");
         hashSet.clear();
    }
}

3.3 遍历内容HashSet

（1）通过foreach遍历

（2）通过迭代器来遍历

Iterator iterator = hashSet.iterator();//获取迭代器对象有序：有下标

while (iterator.hasNext()){//判断是否指定能够移动

Object next = iterator.next();//指定移动并获取当前的元素

public class Test {
    public static void main(String[] args) {
        HashSet  hashSet= new HashSet();
        HashSet  hashSet1 = new HashSet(16);//初始容器的大小
        hashSet.add("java01");
        hashSet.add("java02");
        
        for(Object o: hashSet){
            System.out.println(o);
        }

        Iterator iterator = hashSet.iterator();

        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

3.4 HashSet底层内容

public HashSet() {
map = new HashMap<>();
}
在创建一个HashSet的对象时，底层创建的是HashMap。

4.TreeSet集合

TreeSet中的方法和HashSet中的方法一模一样只是他们的实现不一样。
TreeSet 基于TreeMap 实现。TreeSet可以实现有序集合，但是有序性需要通过比较器实现。

特殊点：存储一个对象类型

public class Test{
    public static void main(String[] args) {
        TreeSet treeSet=new TreeSet();
        treeSet.add(new Student("赵",52));
        treeSet.add(new Student("钱",23));
        treeSet.add(new Student("孙",68));
        treeSet.add(new Student("李",47));

    }
}

TreeSet中的元素必须实现Comparable接口方可放入TreeSet

解决办法有两个:

第一个: 让你的类实现Comparable接口

public class MyComparator implements Comparator {

   //需要比对得两个对象
    @Override
    public int compare(Object o1, Object o2) {
        Student s1= (Student) o1;
        Student s2= (Student) o2;
        if(s1.getAge()>s2.getAge()){
            return 1;
        }else if(s1.getAge()<s2.getAge()){
            return -1;
        }else {
            return 0;
        }
    }
}

第二种: 在创建TreeSet时指定排序的对象。
TreeSet treeSet=new TreeSet(); 但是在创建对象时并没有为其指定排序得规则，那么就要求该集合得元素有排序规则。

如果元素得类已经创建完成，不能修改该类得源码，这时我们又想把该类得对象放入得TreeSet容器中。
这时就需要你在创建TreeSet时指定排序得规则。

public class Demo01 {
    public static void main(String[] args) {
        //Comparator<? super E> comparator
        //为TreeSet容器指定了排序规则
        TreeSet treeSet=new TreeSet(new MyComparator()); 
        treeSet.add(new Student(18,"王亚波"));
        treeSet.add(new Student(17,"潘世浩"));
        treeSet.add(new Student(19,"刘晓东"));
        treeSet.add(new Student(19,"娄明阳"));
        System.out.println(treeSet);
    }
}

5. Map 属于键值对模式

map中得每个元素属于键值对模式。如果往map中添加元素时需要添加key 和 value. 它也属于一个接口，该接口常见得实现类有: HashMap.

5.1 如何创建Map对象

默认初始化大小为16 负载因子为0.75


         Map map=new HashMap();
  
         Map map2=new HashMap(16);

         Map map3=new HashMap(16,0.78f);

5.2 添加操作

1.初始化 Map map=new HashMap();

2.添加操作 变量名.put（"关键键"，“内容”）; //要求map得key必须唯一。

因为key不能重复，所以后者会把前者覆盖

3. 变量名.putAll（变量名）; 把变量中的每个元素添加到map中

4.变量名.putIfAbsent("key",内容) ;//如果指定得key存在，则不放入map中，如果不存在则放入map中


         Map map=new HashMap();
        
         map.put("name","赵"); 
         map.put("age",18);

         Map a=new HashMap();
         m1.put("n1","m1");
         m1.put("n2","m2");
         map.putAll(a); 
 
         map.putIfAbsent("age",28);

5.3 删除操作

map.remove("key");//根据指定得key移除元素

map.clear(); //清空map容器

         map.remove("age");
          
         map.clear();

5.4 修改操作

map.replace("name","内容");//替换元素

5.5 查询

1.判断map是否存在指定得key boolean f = map.containsKey("k5");

2.根据指定的key获取对应得value值 Object v = map.get("k5");

3.返回该map中所有得key Set keys = map.keySet();

4.遍历 map. for(Object k:keys){

Object value= map.get(k); System.out.println(k+"==========>"+value);

}

        boolean f = map.containsKey("k5");//判断map是否存在指定得key

        Object v = map.get("k5"); //根据指定的key获取对应得value值
        System.out.println(v);

        Set keys = map.keySet();//返回该map中所有得key
        System.out.println(keys);
        //遍历map.
        for(Object k:keys){
            Object value= map.get(k);//
            System.out.println(k+"================>"+value);
        }

    }

5.6 HashMap的底层原理

JDK1.7 和 JDK1.8他们是有区别得。

JDK1.7使用得数据结构: 数组+链表而且链表插入模式为头部插入（造成死循环）。

jdk1.8使用得数据结构: 数组+链表+红黑树而且链表得插入模式为尾部插入。

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

6.泛型

1. 泛型就是限制我们得数据类型。

2.为什么使用泛型?
我们原来在定义集合时，获取元素需要进行强制类型转换
获取元素时，不方便对元素进行相应得其他操作。

List<类型> list=new ArrayList<类型>();

这里就限制了集合中每个元素得类型。

在获取元素时默认就是相应得数据类型而无需在进行转换

package com.Java020;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Java001 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("java001");
        String s = list.get(0);

        HashMap<String ,Integer> hashMap= new HashMap<>();
        hashMap.put("age",18);


    }

在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型。

Hu_下笔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合框架的操作使用

集合框架的概述可以将集合框架作为数组来进行理解java官方就基于数组，根据不同的数据结构，封装出来了很多的类，这些类统称为：集合框架。1.List表格1.1 List表格的特点用户可以精确控制列表中每个元素的插入位置用户可以通过列表中的位置访问元素，并搜索列表中的元素常用的增删改查的方法可以简单的理解成和数组的使用方式差不多1.2ArrayList 创建数组（1）先调用类import java.util.ArrayList;import jav...
复制链接

扫一扫

专栏目录