发布日期：2021-06-29 02:38:27 浏览次数：2 分类：技术文章

本文共 9928 字，大约阅读时间需要 33 分钟。

今日内容

1.ArrayList存储字符串

使用迭代器进行遍历

public class Test {
       public static void main(String[] args) {
           ArrayList
   
     list = new ArrayList<>();        list.add(new Student("张三", 23));        list.add(new Student("张三", 23));        list.add(new Student("李四", 24));        list.add(new Student("李四", 24));        list.add(new Student("王五", 25));        list.add(new Student("赵六", 26));        ListIterator
    
      studentListIterator = list.listIterator();        while (studentListIterator.hasNext()) {
               Student next = studentListIterator.next();            System.out.println(next);        }    } }

使用for循环遍历

public class Test {
       public static void main(String[] args) {
           ArrayList
   
     list = new ArrayList<>();        list.add(new Student("张三", 23));        list.add(new Student("张三", 23));        list.add(new Student("李四", 24));        list.add(new Student("李四", 24));        list.add(new Student("王五", 25));        list.add(new Student("赵六", 26));        for (int i = 0; i < list.size(); i++) {
               Student student = list.get(i);            System.out.println(student);        }    }}

2.Vector特有功能

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

Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()
- E firstElement() 返回此向量的第一个组件（位于索引 0) 处的项）。
- E lastElement() 返回此向量的最后一个组件。
- void insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。

3.LinkedList

LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的

LinkedList类特有功能
- public void addFirst(E e)及addLast(E e)
- public E getFirst()及getLast()
- public E removeFirst()及public E removeLast()

练习1:去除ArrayList中重复字符串元素方式（不创建新集合）

使用选择排序法

public class Test {
       public static void main(String[] args) {
           ArrayList
   
     list = new ArrayList<>();        list.add(120);        list.add(120);        list.add(120);        list.add(120);        list.add(205);        list.add(2058);        list.add(200);        list.add(20);        list.add(200);        list.add(20);        list.add(209);        for (int i = 0; i < list.size() - 1; i++) {
               for (int j = i + 1; j < list.size(); j++) {
                   if (list.get(i).equals(list.get(j))) {
                       list.remove(j);                    j--;                 }            }        }        System.out.println(list);    }}

使用递归法

public class Test {
       public static void main(String[] args) {
           ArrayList
   
     list = new ArrayList<>();        list.add(120);        list.add(120);        list.add(120);        list.add(120);        list.add(205);        list.add(2058);        list.add(200);        list.add(20);        list.add(200);        list.add(20);        list.add(209);        list.add(120);        list.add(120);        list.add(120);        list.add(120);        list.add(205);        list.add(2058);        list.add(200);        list.add(20);        list.add(200);        list.add(20);        list.add(209);        list.add(120);        list.add(120);        list.add(120);        list.add(120);        list.add(205);        list.add(2058);        list.add(200);        list.add(20);        list.add(200);        list.add(20);        list.add(209);        deleteEle(list);        System.out.println(list);    }    private static void deleteEle(ArrayList
    
      list) {
           for (int i = 0; i < list.size(); i++) {
               Integer ele = list.get(i);            if (list.indexOf(ele) != list.lastIndexOf(ele)) {
                   list.remove(ele);                deleteEle(list);             }        }    }}

练习2:去除ArrayList中重复字符串元素方式（创建新集合）

public class Test {
       public static void main(String[] args) {
           ArrayList list = new ArrayList();        list.add("aaa");        list.add("bbb");        list.add("ccc");        list.add("aaa");        list.add("bbb");        list.add("ccc");        list.add("aaa");        list.add("bbb");        list.add("ccc");        //去除重复元素        System.out.println(list);        //采用创建一个新容器        ArrayList

4.泛型

概述
- 是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
- 参数化类型，把类型当作参数一样的传递。

泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型

泛型好处
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
- 优化了程序设计，解决了黄色警告线

泛型只在编译期有效但在运行期就擦除了

泛型的由来
- 泛型的由来:通过Object转型问题引入
  早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。

6.泛型类

泛型类概述: 把泛型定义在类上

定义格式: public class 类名<泛型类型1,…>

注意事项: 泛型类型必须是引用类型

public class MyObject
   
     {
       private T obj;    int num;    public T getObj() {
           return obj;    }    public void setObj(T obj) {
           this.obj = obj;    }}

7.泛型方法

泛型方法概述: 把泛型定义在方法上

定义格式: public <泛型类型> 返回类型方法名(泛型类型变量名)

public class MyObject {
       private Object obj;    public Object getObj() {
           return obj;    }    public void setObj(Object obj) {
           this.obj = obj;    }}

8.泛型接口

泛型接口概述: 把泛型定义在接口上

定义格式: public interface 接口名<泛型类型>

public interface MyInterface
   
     {
       void show(E e);}

9.泛型高级之通配符

泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了

? extends E: 向下限定，E及其子类

? super E: 向上限定，E及其父类

案例演示: 泛型高级之通配符的基本使用

/**		 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致		 */		Collection

10.增强for的概述和使用

增强for概述：简化数组和Collection集合的遍历

格式：
for(元素数据类型变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素
}

案例演示
数组，集合存储元素用增强for遍历

public class MyTest {
       public static void main(String[] args) {
           int[] arr = {
   20, 30, 40, 50};        for (int i = 0; i < arr.length; i++) {
               System.out.println(arr[i]);        }        System.out.println("=============================");        //新式for循环 (数据类型 ele:容器名)        //快速生成 arr.for        for (int ele : arr) {
               System.out.println(ele);        }        System.out.println("================================");        ArrayList
   
     list = new ArrayList<>();        list.add(120);        list.add(120);        list.add(120);        list.add(120);        list.add(205);        list.add(2058);        list.add(200);        list.add(20);        list.add(200);        list.add(20);        list.add(209);        for (int i = 0; i < list.size(); i++) {
               System.out.println(list.get(i));        }        System.out.println("===========================");        for (Integer integer : list) {
               System.out.println(integer);        }    }}

好处和注意事项
简化遍历
注意事项：增强for的目标要判断是否为null
注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

11.可变参数的概述和使用

可变参数概述: 定义方法的时候不知道该定义多少个参数

格式: 修饰符返回值类型方法名(数据类型… 变量名){}

注意事项：
a: 这里的变量其实是一个数组
b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

// 可变参数public static int add(int... a){
   	// 定义一个累加变量	int sum = 0 ;	for(int s : a ){
   		sum += s ;	}	return sum;}

12.静态导入语法

import static java.lang.Math.random; 直接导入到静态方法import static java.lang.Math.*; 可以使用统配符把Math类下的所有静态方法都导入使用时可以不用写类名，直接调用方法即可random();

练习：集合嵌套之ArrayList嵌套ArrayList

需求：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList

但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。

而我现在有多个ArrayList。也要用集合存储，怎么办呢?

集合嵌套之ArrayList嵌套ArrayList

// 定义大的集合 ArrayList
     
      
       > allClassList = new  ArrayList
       
        
         >() ;  // 创建每一个班的集合 ArrayList
         
           jcClassList = new  ArrayList
          
           () ;

public class Test {
       public static void main(String[] args) {
           Student s1 = new Student("张三", 23);        Student s2 = new Student("李四", 27);        Student s3 = new Student("王五", 23);        Student s4 = new Student("赵六", 25);        Student s5 = new Student("刘德华", 28);        Student s6 = new Student("张学友", 30);        ArrayList
   
     javaList = new ArrayList<>();        javaList.add(s1);        javaList.add(s2);        javaList.add(s3);        ArrayList
    
      webList = new ArrayList<>();        webList.add(s4);        webList.add(s5);        webList.add(s6);        ArrayList
     
      
       > maxList = new ArrayList<>();        maxList.add(javaList);        maxList.add(webList);         //遍历嵌套集合。        for (int i = 0; i < maxList.size(); i++) {
               ArrayList
       
         minList = maxList.get(i);            for (int j = 0; j < minList.size(); j++) {
                   Student student = minList.get(j);                System.out.println(student.getName() + "===" + student.getAge());            }        }        System.out.println("=================================");        for (ArrayList
        
          students : maxList) { for (Student student : students) { System.out.println(student.getName() + "===" + student.getAge()); } } System.out.println("===================================="); maxList.forEach(new Consumer
         
          
           >() { @Override public void accept(ArrayList
           
             minList) { minList.forEach(new Consumer
            
             () { @Override public void accept(Student student) { System.out.println(student.getName() + "===" + student.getAge()); } }); } }); }}//学生类public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; }}

转载地址：https://blog.csdn.net/yzl109zj125/article/details/117230812 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：JAVA SE之面向对象12：集合3（Set）

下一篇：排序算法整理2：选择排序及其时间与空间复杂度的计算

发表评论

关于作者

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！

-- 愿君每日到此一游！