devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java基础 - 集合框架(3) : List的子类、泛型、可变参数_java 方法参数 list 泛型

作者：花生_TL007 | 2024-02-12 08:57:43

赞

踩

java 方法参数 list 泛型

1. List的子类特点

  • ArrayList : 底层数据结构是数组，查询快，增删慢。 线程不安全，效率高。
  • Vector : 底层数据结构是数组，查询快，增删慢。线程安全，效率低。
  • LinkedList : 底层数据结构是链表，查询慢，增删快。线程不安全，效率高。
  • 查询多 : ArrayList
  • 增删多：LinkedList
  • 什么都不知道，就用ArrayList

2. ArrayList存储自定义对象并遍历

import java.util.ArrayList;
import java.util.Iterator;


public class ArrayListDemo2 {
	public static void main(String[] args) {
		
		ArrayList array = new ArrayList();

		
		Student s1 = new Student("哈狗帮", 68);
		Student s2 = new Student();
		s2.setAge(66);
		s2.setName("中意WAF");
//		Student s3 = new Student("waf", 36);
//		Student s4 = new Student("花和尚", 38);

		
		array.add(s1);
		array.add(s2);
		array.add(new Student("杨腾宇", 26));
//		array.add(s4);

		// 方法1
		Iterator it = array.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();
			System.out.println(s.getName() + "---" + s.getAge());
		}

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

		// 方法2
		for (int x = 0; x < array.size(); x++) {
			// ClassCastException ע�⣬ǧ��Ҫ���������
			// String s = (String) array.get(x);
			// System.out.println(s);

			Student s = (Student) array.get(x);
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

3. 泛型概述和基本使用

  • 概述 : 是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。

  • 格式：<数据类型> 注意：该数据类型只能是引用类型。

  • 好处：

     A. 把运行时期的问题提前到了编译期间
 B. 避免了强制类型转换
 C. 优化了程序设计，解决了黄色警告线问题，让程序更安全

    • 1
    • 2
    • 3
import java.util.ArrayList;
import java.util.Iterator;


public class GenericDemo {
	public static void main(String[] args) {
		
		ArrayList<String> array = new ArrayList<String>();

		
		array.add("hello");
		array.add("world");
		array.add("java");
//		array.add(10);
	
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			// ClassCastException
			// String s = (String) it.next();
			String s = it.next();
			System.out.println(s);
		}

		
		// String[] strArray = new String[3];
		// strArray[0] = "hello";
		// strArray[1] = "world";
		// strArray[2] = 10;
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

4. ArrayList存储自定义对象并遍历(泛型版)

import java.util.ArrayList;
import java.util.Iterator;


public class ArrayListDemo2 {
	public static void main(String[] args) {
		
		// ArrayList<Student> array = new ArrayList<>();
		
		ArrayList<Student> array = new ArrayList<Student>();

	
		Student s1 = new Student("夏侯渊", 40); 
		Student s2 = new Student("赵云", 30); 
		Student s3 = new Student("典韦", 26);

		
		array.add(s1);
		array.add(s2);
		array.add(s3);

		
		Iterator<Student> it = array.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			System.out.println(s.getName() + "---" + s.getAge());
		}
		System.out.println("------------------");

		for (int x = 0; x < array.size(); x++) {
			Student s = array.get(x);
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

5. 泛型的前世今生

  • A. 泛型的由来 : Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
  • B. 泛型类、泛型方法、泛型接口、泛型高级通配符
  • C. 泛型通常在集合中使用

6. 增强for循环

  • 是for循环的一种，其实是用来替代迭代器的

  • 格式：

     for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
 	使用该变量即可，该变量其实就是数组或者集合中的元素。
 }

    • 1
    • 2
    • 3

  • 好处：简化了数组和集合的遍历

  • 弊端 : 增强for循环的目标不能为null。建议在使用前，先判断是否为null

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


public class ForDemo {
	public static void main(String[] args) {
		
		int[] arr = { 1, 2, 3, 4, 5 };
		for (int x = 0; x < arr.length; x++) {
			System.out.println(arr[x]);
		}
		System.out.println("---------------");
		
		for (int x : arr) {
			System.out.println(x);
		}
		System.out.println("---------------");
		
		String[] strArray = { "杨腾宇", "徐康健", "法印" };
		
		for (String s : strArray) {
			System.out.println(s);
		}
		System.out.println("---------------");
		
		ArrayList<String> array = new ArrayList<String>();
		array.add("hello");
		array.add("world");
		array.add("java");
	
		for (String s : array) {
			System.out.println(s);
		}
		System.out.println("---------------");

		List<String> list = null;
		// NullPointerException
		
		if (list != null) {
			for (String s : list) {
				System.out.println(s);
			}
		}

		
		//ConcurrentModificationException
//		 for (String s : array) {
//		 if ("world".equals(s)) {
//		 array.add("javaee");
//		 }
//		 }
//		 System.out.println("array:" + array);
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

7. ArrayList存储字符串并遍历增强for版

import java.util.ArrayList;
import java.util.Iterator;

/*
 * ArrayList存储字符串并遍历
 * A:迭代器
 * B:普通for
 * C:增强for
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		
		ArrayList<String> array = new ArrayList<String>();

		
		array.add("hello");
		array.add("world");
		array.add("java");

		// 迭代器
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		System.out.println("------------------");

		// 普通for
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			System.out.println(s);
		}
		System.out.println("------------------");

		// 增强for
		for (String string : array) {
			System.out.println(string);
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

8. List存储自定义对象并遍历增强for版

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

public class ArrayListDemo2 {

	public static void main(String[] args) {
		
		List<Student> list = new ArrayList<Student>();
		
		Student s1 = new Student("杨腾宇",66);
		Student s2 = new Student();
		s2.setAge(26);
		s2.setName("XKJSMSB");
		
		list.add(s1);
		list.add(s2);
		list.add(new Student("德子", 28));
		
		// 迭代器
		Iterator<Student> it = list.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			System.out.println(s.getAge() + "---" + s.getName());
		}
		
		System.out.println("------");
		
		// 普通for
		for (int i = 0; i < list.size(); i++) {
			Student s = list.get(i);
			System.out.println(s.getAge() + "---" + s.getName());
		}
		
		System.out.println("------");

		// 增强for
		for (Student student : list) {
			System.out.println(student.getAge() + "---" + student.getName());
		}
		
		System.out.println("------");

	}

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

9. 静态导入

  • 可以导入到方法级别的导入
  • 格式 : import static 包名…类名.方法名;
  • 注意事项 1 : 方法必须是静态的
  • 注意事项 2 : 如果多个类下有同名的方法，就不好区分了，还得加上前缀

10. 可变参数

  • 如果我们在写方法的时候，参数个数不明确，就应该定义可变参数

  • 例 : 写一个求和的方法，个个也不确定几个数据求和，但在调用的时候肯定就知道了，这个时候就用可变参数

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

  • 注意 :

     	A. 该变量其实是一个数组名
 	B. 如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

    • 1
    • 2
public class ArgsDemo {
	public static void main(String[] args) {
		
		int a = 10;
		int b = 20;
		int result = sum(a, b);
		System.out.println("result:" + result);

		
		int c = 30;
		result = sum(a, b, c);
		System.out.println("result:" + result);

		
		int d = 30;
		result = sum(a, b, c, d);
		System.out.println("result:" + result);

		
		result = sum(a, b, c, d, 40);
		System.out.println("result:" + result);

		result = sum(a, b, c, d, 40, 50);
		System.out.println("result:" + result);
	}

	public static int sum(int... a) {
		// System.out.println(a);
		//return 0;

		int s = 0;
		
		for(int x : a){
			s +=x;
		}
		
		return s;
	}

	// public static int sum(int a, int b, int c, int d) {
	// return a + b + c + d;
	// }
	//
	// public static int sum(int a, int b, int c) {
	// return a + b + c;
	// }
	//
	// public static int sum(int a, int b) {
	// return a + b;
	// }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

11. Arrays工具类的一个asList()方法的使用

  • 注意事项 : 虽然可以把数组转成集合,但是集合的长度不能改变,可以改变集合中的元素
  • public static List asList(T… a):把数组转成集合
import java.util.Arrays;
import java.util.List;

/*
 * public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项:
 * 		虽然可以把数组转成集合,但是集合的长度不能改变,可以改变集合中的元素。
 */
public class ArraysDemo {
	public static void main(String[] args) {
		
		// String[] strArray = { "hello", "world", "java" };
		// List<String> list = Arrays.asList(strArray);

		List<String> list = Arrays.asList("hello", "world", "java");
		// UnsupportedOperationException
		// list.add("javaee");
		// UnsupportedOperationException
		// list.remove(1);
		list.set(1, "javaee");

		for (String s : list) {
			System.out.println(s);
		}
		
		List<Integer> listWAF = Arrays.asList(6,7,8);
		for (Integer integer : listWAF) {
			System.out.println(integer.intValue());
		}
		
		listWAF.set(0, 66);
		listWAF.set(1, 77);
		listWAF.set(2, 88);

		for (Integer integer : listWAF) {
			System.out.println(integer.intValue());
		}
//		listWAF.add(9);
//		listWAF.remove(1);
		
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

12. 集合嵌套存储和遍历元素的案例

  • 集合存储集合，用两个增强for遍历
import java.util.ArrayList;


public class ArrayListDemo {
	public static void main(String[] args) {
		
		ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();

	
		ArrayList<Student> firstArrayList = new ArrayList<Student>();
		
		Student s1 = new Student("刘备", 30);
		Student s2 = new Student("赵云", 29);
		Student s3 = new Student("马超", 28);
	
		
		firstArrayList.add(s1);
		firstArrayList.add(s2);
		firstArrayList.add(s3);
		
		bigArrayList.add(firstArrayList);

		
		ArrayList<Student> secondArrayList = new ArrayList<Student>();
		
		Student s11 = new Student("曹操", 30);
		Student s22 = new Student("乐进ܲ", 28);
		Student s33 = new Student("张辽", 26);
		
		secondArrayList.add(s11);
		secondArrayList.add(s22);
		secondArrayList.add(s33);
		
		bigArrayList.add(secondArrayList);

		
		ArrayList<Student> thirdArrayList = new ArrayList<Student>();
		
		Student s111 = new Student("孙权", 40);
		Student s222 = new Student("甘宁", 35);
		Student s333 = new Student("太史慈", 30);
		
		thirdArrayList.add(s111);
		thirdArrayList.add(s222);
		thirdArrayList.add(s333);
		
		bigArrayList.add(thirdArrayList);

		
		for (ArrayList<Student> array : bigArrayList) {
			for (Student s : array) {
				System.out.println(s.getName() + "---" + s.getAge());
			}
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

13. 产生10个1-20之间的随机数要求随机数不能重复案例

import java.util.ArrayList;
import java.util.Random;


public class RandomDemo {
	public static void main(String[] args) {
		
		Random r = new Random();

		
		ArrayList<Integer> array = new ArrayList<Integer>();

		
		int count = 0;

		
		while (count < 10) {
			
			int number = r.nextInt(20) + 1;
			
			
			if(!array.contains(number)){
				
				array.add(number);
				count++;
			}
		}
		
		
		for(Integer i : array){
			System.out.println(i);
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

14. 键盘录入多个数据在控制台输出最大值案例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;


public class ArrayListDemo {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);

		
		ArrayList<Integer> array = new ArrayList<Integer>();

		
		while (true) {
			System.out.println("请输入数据,以0结尾:");
			int number = sc.nextInt();
			if (number != 0) {
				array.add(number);
			} else {
				break;
			}
		}

		
		// public <T> T[] toArray(T[] a)
		Integer[] i = new Integer[array.size()];
		// Integer[] ii = array.toArray(i);
		array.toArray(i);
		// System.out.println(i);
		// System.out.println(ii);

		
		// public static void sort(Object[] a)
		Arrays.sort(i);

		
		System.out.println("数组为:" + arrayToString(i) + "最大值为:"
				+ i[i.length - 1]);
	}

	public static String arrayToString(Integer[] i) {
		StringBuilder sb = new StringBuilder();

		sb.append("[");
		for (int x = 0; x < i.length; x++) {
			if (x == i.length - 1) {
				sb.append(i[x]);
			} else {
				sb.append(i[x]).append(", ");
			}
		}
		sb.append("]");

		return sb.toString();
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/blog/article/detail/77343
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号