Java14集合、泛型、新式for循环、可变参数

最新推荐文章于 2023-04-02 13:38:28 发布
最新推荐文章于 2023-04-02 13:38:28 发布
阅读量109 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49324736/article/details/107993058
版权
list
  • 遍历集合
public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add(100);
    list.add(200);
    list.add(300);

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

  • 概述：Vector 类可以实现可增长的对象数组 , Vector 是同步的。

  • 功能：

     void addElement (E obj)
  //添加指定的组件到这个向量的结束，增加其大小由一个。
 E elementAt(int index) //返回指定索引处的组件。
 Enumeration<E> elements()// 返回此向量的组件的枚举。
 E firstElement() //返回第一个组件（在指数 0项目）这个载体。
 E lastElement() //返回向量的最后一个组件。
boolean removeElement(Object obj) //从该向量中移除第一个（最低索引）发生的参数。
void removeElementAt(int index) //在指定的索引中删除组件。
void setElementAt(E obj, int index) //设置组件在指定的 index这个向量是指定的对象。
LinkedList

  • 概述：List 接口的链接列表实现 , 此实现不是同步的

  • 功能

    void addFirst(E e)； 
//在此列表的开始处插入指定的元素。
void addLast(E e)；
//将指定的元素列表的结束。
E getLast()；
//返回此列表中的最后一个元素。

E peek()；
//检索，但不删除，此列表的头（第一个元素）。
E peekFirst()；
//检索，但不删除该列表的第一个元素，或返回 null如果这个列表是空的。
E peekLast()
//检索，但不删除该列表的最后一个元素，或返回 null如果这个列表是空的。
    
E poll()
//检索并删除此列表的头（第一个元素）。
E pollFirst()
//检索并移除此列表的第一个元素，或返回 null如果这个列表是空的。
E pollLast()
//检索并移除此列表的最后一个元素，或返回 null如果这个列表是空的。
    
E pop()
//从这个列表所表示的堆栈中弹出一个元素。
void push(E e)
//将一个元素推到由该列表所表示的堆栈上。
E removeLast()
//移除并返回此列表中的最后一个元素。
E removeFirst()
//移除并返回此列表中的第一个元素。

  • 例：

      //需求：请用LinkedList模拟栈数据结构的集合，并测试
//栈的特点：先进的后出，后进的先出。
 public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addFirst(200);
        list.addFirst(300);
        list.addFirst(400);
        Object first = list.pop();
        list.addLast(first);
        Object first1 = list.pop();
        System.out.println(first);
        list.addLast(first1);
        Object first2 = list.pop();
      System.out.println(first1);
        list.addLast(first2);
    }

  • 去掉集合中重复的元素

    public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add(20);
    list.add(20);
    list.add(20);
    list.add(20);
    list.add(120);
    list.add(320);
    list.add(320);
    list.add(120);
    list.add(20);
    list.add(230);
    list.add(204);
    list.add(203);
    list.add(20);
    list.add(120);
    list.add(320);
    list.add(320);
    list.add(120);
    list.add(20);
    list.add(230);
    list.add(204);
    list.add(203);
    for (int i = 0; i < list.size() - 1; i++) {
            Object o = list.get(i);
            if (list.indexOf(o) != list.lastIndexOf(o)) {
                list.remove(o);
                i--;
        }
    }
    System.out.println(list);
}

  • ArrayList去除集合中字符串的重复值(字符串的内容相同)

    public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add("aaa");
    list.add("aaa");
    list.add("bbb");
    list.add("bbb");
    list.add("ccc");
    list.add("ccc");
    ArrayList newList = new ArrayList();
    for(int i=0;i<list.size();i++){
        Object o=list.get(i);
        if(!newList.contains(o)){
            newList.add(o);
        }
    }
    System.out.println(newList);
}
泛型机制

  • 泛型机制：JDK1.5之后引入的一种机制。就是把数据类型明确工作，推迟到创建对象或调用方法时，才去明确的一种机制。
    泛型的好处：能够提高代码的扩展性，避免了向下转型，可以将问题提前到编译期。

  • 泛型，只在编译期，有效在运行期，就擦除了。

  • 如果不规定泛型，在输出时需要进行向下转型，否则会报错。

    ArrayList list = new ArrayList();
list.add("abc");
list.add(100);
list.add(3.21);

Object o = list.get(0);
String str= (String) o;
System.out.println(str.length());

  • 规定泛型后就不需要进行向下转型。

    ArrayList<String> list2 = new ArrayList<String>();

list2.add("abc");
String s = list2.get(0);
System.out.println(s);

  • 泛型类

    public class MyClass<T> {
    private T t;
    private Integer num;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}
//泛型类型必须是引用类型

  • 泛型接口

    interface Inter<T> {
    public void show(T t);
}
class demo implements Inter<String>{
    public void show(String str){     System.out.println(str);
    }
}
//当实现类确定传入的类型时，可以直接指定类型

    interface Inter<T> {
    public void show(T t);
}
class demo<T> implements Inter<T>{
    public void show(T t){
        System.out.println(t);
    }
}

  • 泛型方法

        Class Demo{
public <T> void test1(T t){
        System.out.println("this is test1" + t);
        }
public <T> void test2(T t){
        System.out.println("this is test2" + t);
        }
}/*由于泛型类的所有方法都只能使用同一不确定的类型。
那么当我们需要不同方法操作不同的不确定类型时，就可以将泛型定义在方法上。*/

  • 泛型通配符

    public class MyTest {
    public static void main(String[] args) {
        //? 泛型通配符
        ArrayList<?> objects = new ArrayList<Dog>();
        ArrayList<?> objects2 = new ArrayList<Cat>();
        ArrayList<?> objects3 = new ArrayList<Animal>();
        System.out.println("====================================");
        //向上限定
        ArrayList<? super Cat> list = new ArrayList<Animal>();
        ArrayList<? super Animal> list2 = new ArrayList<Animal>();
        ArrayList<? super Animal> list3 = new ArrayList<Object>();

        //向下限定
        ArrayList<? extends Animal> list4 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list5 = new ArrayList<Cat>();
        ArrayList<? extends Animal> list6 = new ArrayList<Dog>();

        System.out.println("============================================");

        ArrayList<Integer> a= new ArrayList<>();
        a.add(200);

        ArrayList<Integer> b = new ArrayList<>();
        b.add(2000);

        a.addAll(b);

    }
}

class Animal{

}

class Dog extends Animal{

}

class Cat extends Animal{

}
新式for循环

  • 老式

    int[] arr={20,30,50};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

  • 新式

    //for(容器中的元素的数据类型 变量名:容器名)
for(int a:arr){
    System.out.println(a);
}

  • 注意：新式for循环在遍历集合时，底层用的还是迭代器，你在遍历途中，如果改变集合的长度，就会报并发修改异常（ConcurrentModificationException）。

可变参数

  • 可变参数，本质是一个数组，一次可以接收多个同类型的参数。

  • //如果一个方法的形参有多个参数，那么可变参数，应该是最后一个。
private static int add(int b,int... a) {
    int sum=b;
    for (int i : a) {
        sum += i;
    }
    return sum;
}

  • 把一个数组转换集合。
 int[] arr={20,30,40};
//传的是一个基本类型的数组，他是把这个数组对象，放到集合中
 List<int[]> ints = Arrays.asList(arr);
 System.out.println(ints); //[[I@1b6d3586] 
//传入的是一个包装类型的数组，他是吧数组中的元素，取出来放到集合中
System.out.println(ints.get(0)[0]); //20
 Integer[] arr2 = {20, 30, 40};
List<Integer> integers = Arrays.asList(arr2); System.out.println(integers);//[20, 30, 40]
//传入多个包装类型的数组，那么他是把多个数组对象，放到集合中。
Integer[] arr3 = {20, 30, 40};
Integer[] arr4 = {20, 30, 400};
List<Integer[]> integers1 = Arrays.asList(arr3, arr4);
Integer integer = integers1.get(1)[2];   System.out.println(integer);//400
m0_49324736
关注
专栏目录
Java入门笔记14（增强for循环）
stronger_nohair的博客
02-08 163
增强for循环 Java5中引入的一种主要用于数组或集合的增强型for循环 语法格式： for(声明语句 ； 表达式){ //代码句子 } 声明句子：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时的数组元素的值相等。 表达式：表达式时要访问的数组名，或者时返回值为数组的方法。 学习地点狂神说Java ...
list三个子类 泛型 可变参数 新式for循环
xiangbaoo的博客
07-18 444
ArrayList存储字符串并遍历 JDK1.8新增的一个方法也能遍历集合 ​ void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 A:案例演示: ArrayList存储字符串并遍历 迭代器 普通for Vector的特有功能 A:Vector类概述: Vector 类可以实...
JAVA List集合、泛型、增强for循环、方法中的可变参数、嵌套集合
weixin_35995730的博客
11-08 562
文章目录JAVA集合对象数组JAVA集合概述：Collection集合的功能概述:JAVA集合——list类List概述及特点List的遍历：（案例）ListIterator的特有功能：并发修改异常产生的原因及解决方案数据结构的理解与特性List的三个子类的特点 JAVA集合 对象数组 案例： 需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。 代码示例...
java 集合与泛型_java的集合和泛型的知识点归纳1
weixin_29289821的博客
02-12 239
【Collection、泛型】主要内容Collection集合迭代器增强for泛型教学目标[ ] 能够说出集合与数组的区别[ ] 说出Collection集合的常用功能[ ] 能够使用迭代器对集合进行取元素[ ] 能够说出集合的使用细节[ ] 能够使用集合存储自定义类型[ ] 能够使用foreach循环遍历集合[ ] 能够使用泛型定义集合对象[ ] 能够理解泛型上下限[ ] 能够阐述泛型通配符的作...
JavaSE ArrayList Vector LinkedList 泛型(Generic) 可变参数 增强for循环
qq_43563187的博客
01-06 169
day16目录： ArrayList Vector LinkedList 泛型(Generic) 可变参数 增强for循环 16.01_集合框架(ArrayList存储字符串并遍历)(掌握) JDK1.8新增的一个方法也能遍历集合 void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 A:案例演示: ArrayList存储字符串并遍历 迭代器 普通for 16.02_集合
JavaSE学习总结（十二）对象数组CollectionListArrayListVectorLinkedList并发修改异常泛型新式for循环可变参数asList()集合嵌套
long3359的博客
04-02 223
JavaSE学习总结（十二）对象数组/Collection/List/ArrayList/Vector/LinkedList/并发修改异常/泛型/新式for循环/可变参数/asList()/集合嵌套 一、对象数组 （一）概述 数组元素可以是基本数据类型，也可以是类对象，这样的数组称为对象数组。在这种情况下，数组的每一个元素都是一个对象的引用。 （二）使用 案例演示 需求：我有3个学生，请把这3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。 //定义学生类 class Student {
Java中的泛型、新式for循环、asList()方法和集合（set类集合）
weixin_45082647的博客
02-09 686
1、Java中的泛型机制 泛型：是JDK1.5之后引入的一个概念，它的存在是指将类型明确工作推迟到创建对象或调用方法时才明确 语法格式：<数据类型，数据类型，……> 泛型可以用在类、接口、方法上 泛型的好处：1、避免了向下转型 2、将问题提前到编译期 泛型的特点：泛型只在编译期有效，在运行期间就擦除了 ...
Java学习记录 Day14（List集合、泛型、for-each、可变参数）
赈川
05-07 551
Day 14 2019年5月3日。 这是我来到西部开源的第十四天。 这一天，我学到了以下的知识。 集合 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类 集合和数组的区别有 长度区别: 数组的长度是固定的而集合的长度是可变的 存储数据类型的区别: 数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型 内容区别: 数组只能...
[Java语言基础]ArrayList 、Vector 、LinkedList 、泛型(Generic)、 可变参数 、增强for循环、Arrays工具类的asList(T... t)方法
Hi~ 土拨鼠
11-06 162
ArrayList JDK1.8新增的一个方法也能遍历集合 ​ void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 ​ import java.util.ArrayList; import java.util.function.Consumer; public class My...
Java中的集合
weixin_63261150的博客
07-01 1898
集合：集合是java中提供的一种容器，可以用来存储多个数据。集合和数组既然都是容器，它们有啥区别呢？ 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。1.2 集合框架 Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。 List的特点是
java进阶--Collection&泛型(IDEA版)
xiaohan0010的博客
03-03 564
本节目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ...
Java学习笔记02---------------Collection、泛型
请叫我星星的博客
08-17 188
主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集...
Collection集合、Iterator迭代器、foreach、泛型、斗地主发牌案例
wssh1854的博客
01-30 248
集合与数组的区别；Collection集合的常用功能；使用迭代器对集合进行取元素；说出集合的使用细节；使用集合存储自定义类型；使用foreach循环遍历集合；使用泛型定义集合对象；理解泛型上下限；阐述泛型通配符的作用
java入门~第十七天 list集合
weixin_41924998的博客
08-11 258
list集合(有序可重复) 1ArrayList 1.01ArrayList(有序可重复)存储字符串并遍历 JDK1.8新增的一个方法也能遍历集合 ​ void forEach 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 。 public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(20); list.add(120); list.
Javaweb3：CSS、弹性盒子布局
m0_49324736的博客
09-30 2311
CSS 属性设置 边框设置 <style type="text/css"> div{ width: 500px; height: 450px; border: black 1px solid; background-image: url(img/2.jpg); <!--设置图片是否重复填充--> background-repeat: no-repeat; <!--设置图片位置 值1左右 值2上下-->
java 1（计算机基础知识）
m0_49324736的博客
07-12 475
java 1（计算机基础知识） 人机交互 人机交互的两种方式 1.图形化界面方式 ： 这种方式简单直观，使用者易于接受，容易上手操作 2.命令行方式： 需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。 键盘快捷键 a:Ctrl+A 全选 b:Ctrl+C 复制 c:Ctrl+V 粘贴 d:Ctrl+X 剪切 e:Ctrl+Z 撤销 f:Ctrl+S
JavaScript4：JSON、AJAX、；jQuery
m0_49324736的博客
10-20 321
JavaScript JSON //数据的封装 <script type="text/javascript"> //ES5没有类的概念 有对象 ES6 class 类这个概念 //name age sex eat() sleep() function Student(name, age, sex) { //alert("构造函数调用了") this.n
Java 9 传参与返回值、链式编程、内部类、Object类
m0_49324736的博客
07-29 276
传参与返回值 当以后看到一个方法的形参类型是一个类 类型，就返回一个该类的对象 当以后看到一个方法的形参要一个抽象类 类型，就传递一个该类型的子类对象。 当以后看到一个方法的形参要一个接口 类型，就传递一个接口的子类对象。 当以后看到一个方法的返回值类型要一个类 类型，你、就返回一个该类的对象。 当以后看到一个方法的返回值类型要一个抽象类 类型，你要返回一个该类的子类对象。 当以后看到一个方法的返回值类型要一个接口类型，就返回一个该接口的子类对象 链式编程 链式编程的语法风格：当调用完一个方法后
java set泛型_Java中的Set集合，泛型，可变参数
最新发布
05-26
同时，Java中的Set集合也支持可变参数，我们可以使用以下方式来添加多个元素： ``` set.addAll("a", "b", "c"); ``` 这样就可以将a、b、c三个元素添加到set集合中。 需要注意的是，由于Set集合不允许重复元素，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值