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

最新推荐文章于 2022-01-10 17:39:22 发布

酷爱WAF哈狗帮

最新推荐文章于 2022-01-10 17:39:22 发布

阅读量397

点赞数

本文链接：https://blog.csdn.net/HuashirenYty/article/details/97616449

版权

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());
		}
	}
}

3. 泛型概述和基本使用

概述 : 是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
格式：<数据类型> 注意：该数据类型只能是引用类型。

好处：

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

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;
	}
}

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());
		}
	}
}

5. 泛型的前世今生

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

6. 增强for循环

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

格式：

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

好处：简化了数组和集合的遍历
弊端 : 增强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);
	}
}

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);
		}
	}
}

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("------");

	}

}

9. 静态导入

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

10. 可变参数

如果我们在写方法的时候，参数个数不明确，就应该定义可变参数
例 : 写一个求和的方法，个个也不确定几个数据求和，但在调用的时候肯定就知道了，这个时候就用可变参数
格式 : 修饰符返回值类型方法名(数据类型… 变量) { }

注意 :

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

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;
	// }
}

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);
		
	}
}

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());
			}
		}
	}
}

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);
		}
	}
}

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();
	}
}

酷爱WAF哈狗帮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础 - 集合框架(3) : List的子类、泛型、可变参数

1. List的子类特点ArrayList : 底层数据结构是数组，查询快，增删慢。线程不安全，效率高。Vector : 底层数据结构是数组，查询快，增删慢。线程安全，效率低。LinkedList : 底层数据结构是链表，查询慢，增删快。线程不安全，效率高。查询多 : ArrayList增删多：LinkedList什么都不知道，就用ArrayList...
复制链接

扫一扫