首页 > 编程语言 >0基础学java之Day24

0基础学java之Day24

时间：2024-11-26 09:02:54浏览次数：13  
标签：java Day24 ArrayList list System add 基础 println out

泛型

  • 泛型常用规范：

  • E - element - 元素

  • T - type - 类型

  • N - name - 名字

  • K - key - 键

  • V - value - 值

  • 泛型的作用：规定数据类型，所以泛型叫做数据安全的做法

  • 注意：

  • 1.在类上定义泛型，创建该类的对象时就需要定义泛型类型

  • 2.泛型必须是引用数据类型

  • 3.泛型只在编码阶段有效，泛型不会随着编译而编译到class文件

  • 4.泛型可以有多个，使用逗号隔开 -- public class HashMap<K,V>{}

1.为什么要有泛型？

如果没有泛型，我们在使用集合等很多类的API时，会有：

  • 麻烦：需要强制类型转换

  • 不安全：在编译时不会对类型提前检查

Java5版本引入了泛型，并且对集合、比较器等很多类做了修改，使得它们支持泛型，变的更好用，更安全。

package com.atguigu.generic;
​
import org.junit.Test;
​
import java.util.ArrayList;
​
public class TestCollection {
    @Test
    public void test1(){
        //未使用泛型
        //集合，是一种用来装多个对象的容器类型。
        //容器的类型有很多，咱们举一个ArrayList来演示
        //ArrayList：动态数组
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");
        list.add(888);
​
        //遍历它，使用增强for循环
        //遍历集合，查看每一个字符串元素的长度
        for (Object o : list) {
            String str = (String) o;//强转
            System.out.println(str +"的长度：" + str.length());
        }
    }
​
    @Test
    public void test2(){
        //有泛型
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("atguigu");
//        list.add(888);//编译就报错了，不符合元素的类型要求
​
        //遍历它，使用增强for循环
        //遍历集合，查看每一个字符串元素的长度
        for (String str : list) {
            System.out.println(str +"的长度：" + str.length());
        }
    }
}
​

2.泛型限定

//?表示任意的引用数据类型
public static ArrayList<?> method01(){
    ArrayList<Object> list = new ArrayList<>();
    return list;
}
​
//? extends A 表示A类或A的子类类型
public static ArrayList<? extends A> method02(){
    //ArrayList<A> list = new ArrayList<>();
    ArrayList<B> list = new ArrayList<>();
    return list;
}
​
//? super A 表示A类或A的父类类型
public static ArrayList<? super A> method03(){
    //ArrayList<A> list = new ArrayList<>();
    ArrayList<Object> list = new ArrayList<>();
    return list;
}

集合

Collection接口

List接口
ArrayList常用方法
public static void main(String[] args) {
        
        ArrayList<String> list = new ArrayList<>();
    
    //添加元素
    list.add("小红");
    list.add("小绿");
    list.add("小蓝");
    list.add("小紫");
    
    //添加元素到指定下标上
    list.add(1, "猪猪");
    
    //将newlist1中所有的元素添加到list集合末尾的位置
    ArrayList<String> newlist1 = new ArrayList<>();
    Collections.addAll(newlist1, "aaa","bbb","ccc","ccc");//利用集合工具批量添加元素
    list.addAll(5, newlist1);
    
    //将newList2中所有的元素添加到list集合指定下标的位置
    ArrayList<String> newlist2 = new ArrayList<>();
    Collections.addAll(newlist2, "xxx","yyy","zzz","zzz","abc","def","ghi","jkl");//利用集合工具类批量添加元素
    list.addAll(5, newlist2);
​
    
    
    //获取指定下标上的位置
    String str = list.get(1);
    System.out.println(str);//猪猪
    
    //获取元素个数
    int size = list.size();
    System.out.println(size);//9
    
    //清空
    //list.clear();
    
    System.out.println("判断集合中是否有某个元素："+list.contains("猪猪"));//true
    System.out.println("判断集合是否为空："+list.isEmpty());//false
    
    System.out.println("判断集合中指定元素第一次出现的下标："+list.indexOf("ccc"));//7
    System.out.println("判断集合中指定元素最后一次出现的下标："+list.lastIndexOf("ccc"));//8
    
    list.remove(1);//根据下标删元素
    list.remove("小紫");//根据元素删元素
    
    //删除list中包含了newlist1的元素（去交集）
    list.removeAll(newlist1);
    
    //保留list中包含了newlist2的元素（保留交集）
    list.retainAll(newlist2);
    
    //替换/设置指定下标上的元素
    list.set(0, "小紫");
    
    System.out.println(list);
    
    //获取开始下标处到结束下标处的元素，并返回新的集合
    List<String> subList = list.subList(3, 6);
    //将集合转为Object数组
    Object[] array1 = subList.toArray();
    System.out.println(Arrays.toString(array1));
    //将集合转换为指定类型的数组
    String[] array2 = new String[subList.size()];
    subList.toArray(array2);
    System.out.println(Arrays.toString(array2));
    
    
    System.out.println("----------------------");
    
    // 遍历集合--for循环
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    
    System.out.println("----------------------");
    
    //遍历集合--Iterator
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String element = it.next();
        System.out.println(element);
    }
    
    System.out.println("----------------------");
    
    //遍历集合--ListIterator
    ListIterator<String> listit = list.listIterator();
    while(listit.hasNext()){
        String element = listit.next();
        System.out.println(element);
        }
    
    //ListIterator的删除
     ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            String element = listIterator.next();
            if(element.equals("椎名空")){
                listIterator.remove();
            }
        }
    
    //ListIterator的添加
    ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            String element = listIterator.next();
            if(element.equals("椎名空")){
                listIterator.add("曾子俊");
            }
        }
        
    //ListIterator的替换
    ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            String element = listIterator.next();
            if(element.equals("椎名空")){
                listIterator.set("曾子俊");
            }
        }
    //ListIterator的指定下标遍历
    ListIterator<String> listIterator = list.listIterator(1);
        while(listIterator.hasNext()){
            String element = listIterator.next();
            System.out.println(element);
        }
    //ListIterator的倒序遍历
    ListIterator<String> listIterator = list.listIterator(list.size());
        while(listIterator.hasPrevious()){//判断上一个是否有可迭代的元素
            String element = listIterator.previous();//获取上一个元素
            System.out.println(element);
        }
        
        for (String element : list) {
            System.out.println(element);
        }
 
    }
LinkedList

除了拥有ArrayList的常用方法还有其独特方法

LinkedList<String> list = new LinkedList<>();
        
        list.add("小红");
        list.add("小黄");
        list.add("xxx");
        list.add("小绿");
        list.add("yyy");
        list.add("小紫");
        list.add("xxx");
        list.add("小粉");
        list.add("xxx");
        
        //将元素添加到集合的首位
        list.addFirst("小蓝");
        list.offerFirst("小灰");
        list.push("小黑");
        
        //将元素添加到集合的末尾
        list.addLast("aaa");
        list.offer("bbb");
        list.offerLast("ccc");
        
        //获取第一个元素
        System.out.println("获取第一个元素：" + list.element());
        System.out.println("获取第一个元素：" + list.getFirst());
        System.out.println("获取第一个元素：" + list.peek());
        System.out.println("获取第一个元素：" + list.peekFirst());
        
        //获取最后一个元素
        System.out.println("获取最后一个元素：" + list.getLast());
        System.out.println("获取最后一个元素：" + list.peekLast());
        
        //删除第一个元素
        System.out.println("删除第一个元素：" + list.poll());
        System.out.println("删除第一个元素：" + list.pollFirst());
        System.out.println("删除第一个元素：" + list.pop());
        System.out.println("删除第一个元素：" + list.removeFirst());
        
        
        //删除最后一个元素
        System.out.println("删除最后一个元素：" + list.pollLast());
        System.out.println("删除最后一个元素：" + list.removeLast());
        
        //删除第一个出现的元素
        list.removeFirstOccurrence("xxx");
        
        //删除最后一次出现的元素
        list.removeLastOccurrence("xxx");
        
        //倒序遍历
//      Iterator<String> descendingIterator = list.descendingIterator();
//      while(descendingIterator.hasNext()){
//          String element = descendingIterator.next();
//          System.out.println(element);
//      }
        
        System.out.println("------------------------------");
        
        for (String element : list) {
            System.out.println(element);
        }
    }
​
​
//队列模式（先进先出）
    
public static void main(String[] args) {
        
        LinkedList<String> list = new LinkedList<>();
        
        list.add("1111");
        list.add("2222");
        list.add("3");
        list.add("小红");
        list.add("小黑");
        
        while(!list.isEmpty()){
            String element = list.removeFirst();
            System.out.println(element);
        }
        
        System.out.println("元素个数为：" + list.size());//0
    }
​
//栈模式（先进后出、后进先出）
把list.removeFirst()改成list.removeLast()就ok
​

标签：java,Day24,ArrayList,list,System,add,基础,println,out
From： https://blog.csdn.net/2301_81594623/article/details/144039796

相关文章

  • MySQL面试攻略：从基础到高级，全面解析
    ......
  • 计算机毕业设计-基于Java+springboot架构的航班进出港管理系统项目开发实战(附源码+论
    大家好！我是程序员一帆，感谢您阅读本文，欢迎一键三连哦。......
  • 计算机毕业设计-基于Java+springboot架构的考务报名平台系统项目开发实战(附源码+论文
    大家好！我是程序员一帆，感谢您阅读本文，欢迎一键三连哦。......
  • Java毕业设计-基于Springboot+Vue框架的航班进出港管理系统项目实战(附源码+论文)
    大家好！我是程序猿老A，感谢您阅读本文，欢迎一键三连哦。......
  • Java编程----利用Map集合设计一个车站上下车的程序
    1.将以下车站对应关系的数据存储到map集合中，key：表示站编号，value：表示站名，并遍历打印(可以不按顺序打印)：2.计算地铁票价规则：总行程3站内（包含3站）收费3元，3站以上但不超过5站（包含5站）的收费4元，5站以上的，在4元的基础上，每多1站增加......
  • Java编程学习五
    一、数组的缺陷：二、集合框架三、Vector类四、ArrayList集合五、LinkedList集合六、泛型七、HashSet八、HashMap一、数组的缺陷：1.数组存在定容问题，一旦定义长度，就固定了容量，有时候定义的数据量不一定，很难保证容量不越出；如果需要存储更多或更少的元素，可能需要创建一个新......
  • Java编程学习六
    javaIO操作：Java中，Io操作主要是指使用Java进行输入和输出操作。Java中所有的IO机制都是基于数据流进行输入输出的。这些数据流表示了字符或者字节数据的流动序列。在Java中进行io操作，通常需要用到Java.io包中的类。比如说fiel类，用于表示文件和目录路径名的抽象表示形式。。......
  • Java学习笔记——2024.11.25
    2024.11.25一、Java_DOS原理1.DOS基本原理创建文件夹=>mdd:\\xxx消除文件夹=>rdd:\\xxx2.相对路径和绝对路径=>相对路径：从当前目录开始定位，形成的一个路径=>绝对路径：从顶级目录d，开始定位，形成的路径举例子：相对路径：..\..\abc2\test200\hello.txt......
  • 最小覆盖子串（java）
    给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。注意：对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。如果 s 中存在这样的子串，我们保......
  • strupr(arr)；模拟实现(c基础)
    hi,I am36适合对象c语言初学者strupr(arr);函数是把arr数组变为大写字母，并返回arr介绍一下strupr(arr)；(c基础）-CSDN博客现在进行My__strupr(arr);模拟实现#include<stdio.h>//My__strupr(arr);//返回值为arr(地址),于是用指针变量,原数组为字符型//所以char*ret......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99