28.集合框架基础

最新推荐文章于 2022-08-09 22:13:12 发布

尘迦子

最新推荐文章于 2022-08-09 22:13:12 发布

阅读量125

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_44373403/article/details/102511799

版权

JavaSE 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

集合框架

1.对象数组的概述和使用

package heima_day15;
import com.heima.bean.Student;
public class Demo1_colletion {

     /**

      * 

      * 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
           Student[] arr = new Student[5];                      //存储学生对象
           arr[0] = new Student("张三", 23);
           arr[1] = new Student("李四", 24);
           arr[2] = new Student("王五", 25);
          arr[3] = new Student("赵六", 26);
           arr[4] = new Student("马哥", 20);          
           for (int i = 0; i < arr.length; i++) {
               System.out.println(arr[i]);
           }
      */
     public static void main(String[] args) {
           //int [] <u>arr</u> = new int[5]; 基本数据类型数组
           Student[] arr = new Student[5];//创建引用数据类型数组
           //ctrl+shift+o 导包
           arr[0] = new Student("张三", 23);//创建一个学生对象，存储再数组的第一个位置
           arr[1] = new Student("李四", 24);
           arr[2] = new Student("王五", 25);
           arr[3] = new Student("赵六", 26);
           arr[4] = new Student("马哥", 20);        
           for(int i =0; i < arr.length;i++ ) {
                System.out.println(arr[i]);
           }
     }
}

创建学生类

package com.heima.bean;
public class Student {
     private String name;
     private int age;

     //alt+shift+s(source)Generate Constructors from Superclass 空参构造
     public Student() {
           super();        
     }

     //alt+shift+s(source)+o   Generate Constructors using Fields     有参构造
     public Student(String name, int age) {
           super();
           this.name = name;
           this.age = age;
     }
     //alt+shift+s   +r    get方法
     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 //重写toString
     public String toString() {
           return "Student [name=" + name + ", age=" + age + 
"]";
     }
     /*如果没有重写，打印的结果
      * com.heima.bean.Student@46daef40
           com.heima.bean.Student@12f41634
           com.heima.bean.Student@13c27452
           com.heima.bean.Student@262b2c86
           com.heima.bean.Student@371a67ec
      */
}

在这里插入图片描述

2.集合的由来及集合继承体系图

集合的由来
数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少.
数组和集合的区别
1. 区别1 :
  数组既可以存储基本数据类型,又可以存储引用数据类型,
  基本数据类型存储的是值,
  引用数据类型存储的是地址值
  集合只能存储引用数据类型(对象)
  集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
2. 区别2:
  数组长度是固定的,不能自动增长
  集合的长度的是可变的,可以根据元素的增加而增长
数组和集合什么时候用
1. 如果元素个数是固定的推荐用数组
2. 如果元素个数不是固定的推荐用集合
集合的底层实现方式：
一开始创建一个10个容量大小的数组，当需要的时候，创建一个1.5倍大小的数组，然后将越来的数组拷贝进来，再将原数组变成垃圾。会出现浪费内存的现象
集合继承体系图

3.泛型

3.1.泛型概述和基本使用

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

import heima_day16_bean.Person;

public class Demo5_Generic {
	/**
	* A:泛型概述
	* 
	* B:泛型好处
		* 提高安全性(将运行期的错误转换到编译期) 
		* 省去强转的麻烦
	* C:泛型基本使用
		* <>中放的必须是引用数据类型 
	* D:泛型使用注意事项
		* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) 
	 */
	public static void main(String[] args) {
		//int [] arr = new byte[5];//数据需要保证前后的数据类型一致，集合泛型也是如此
		ArrayList<Person> list = new ArrayList<Person>();
		//ArrayList<Object> list = new ArrayList<>();//1.7版本特性，菱形泛型  泛型不要定义成Object,没有意义
		//list.add(111);
		//list.add(true);
		list.add(new Person("张三",23));
		list.add(new Person("李四",24));
		Iterator<Person> it = list.iterator();
		while(it.hasNext()) {
			//System.out.println(it.next());
			Person p =it.next();
			System.out.println(p.getName()+"   "+p.getAge());//类型转换异常
			//System.out.println(it.next().getName()+"  "+it.next().getAge());
			//next方法只能使用一次，如果多次调用，就会造成指针移动
		}
	}

}

3.2.ArrayList存储字符串和自定义对象并遍历泛型

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

public class Demo6_Generic {
	/**
	* A:案例演示
	* ArrayList存储字符串并遍历泛型版
	 */
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

3.3.泛型的由来

案例演示
泛型的由来:通过Object转型问题引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

3.4.泛型类的概述及使用

A:泛型类概述
- 把泛型定义在类上
B:定义格式
- public class 类名<泛型类型1,…>
C:注意事项
- 泛型类型必须是引用类型
D:案例演示
- 泛型类的使用

3.5.泛型方法的概述和使用

A:泛型方法概述
- 把泛型定义在方法上
B:定义格式
- public <泛型类型> 返回类型方法名(泛型类型变量名)
C:案例演示
- 泛型方法的使用

3.6.泛型接口的概述和使用

A:泛型接口概述
- 把泛型定义在接口上
B:定义格式
- public interface 接口名<泛型类型>
C:案例演示
- 泛型接口的使用

3.7.泛型高级之通配符

A:泛型通配符<?>
- 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E
- 向下限定，E及其子类
C:? super E
- 向上限定，E及其父类

4.增强for的概述和使用

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

import heima_day16_bean.Person;

public class Demo7_foreach {
	/**
			* A:增强for概述
			* 简化数组和Collection集合的遍历
			* B:格式：
			* 
					for(元素数据类型 变量 : 数组或者Collection集合) {
						使用变量即可，该变量就是元素
					}
			* C:案例演示
				* 数组，集合存储元素用增强for遍历
			* D:好处
				* 简化遍历
	 */
	public static void main(String[] args) {
		int [] arr = {11,22,33,44,55};
		for(int i : arr) {
			System.out.println(i);
		}
		//fore快捷键
		
		ArrayList<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		for (String string : list) {
			System.out.println(string);
		}
		
		ArrayList<Person> list1 = new ArrayList<Person>();
		list1.add(new Person("张三",23));
		list1.add(new Person("张1",24));
		list1.add(new Person("张2",25));
		list1.add(new Person("张3",26));
		for (Person person : list1) {
			System.out.println(person);
		}
		
		//1，普通for循环删除
		for(int i = 0; i < list.size();i++) {
			if("b".equals(list.get(i))) {
				list.remove(i--);//通过索引删除元素
			}
		}
		System.out.println(list);
		
		//2.迭代器删除
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			if("d".equals(it.next())) {
				//list.remove("b");不能用集合的删除方法，因为迭代的过程中会出现并发修改异常
				it.remove();	
			}
		}
		System.out.println(list);
		/**
		//3.增强for循环 无法实现，因为底层依赖的是迭代器
		for(String string : list) {
			if("c".equals(string)) {
				list.remove("c");
			}
		}
		System.out.println(list);
		*/
	}
	
}

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

package heima_day16;

public class Demo8_ChangeableArgs {
	/**
	* A:可变参数概述
	* 定义方法的时候不知道该定义多少个参数
	* B:格式
		* 修饰符 返回值类型 方法名(数据类型…  变量名){}
	* C:注意事项：
		* 这里的变量其实是一个数组
		* 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
	 */
	public static void main(String[] args) {
		int [] arr = {11,22,33,44,55};
		print(11,22,33,44,55);
		System.out.println("----");
		print();
	}
	/**
	public static void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	*/
	public static void print(int ... arr) {//可变参数其实是一个数组
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
}

6.Arrays工具类的asList()方法的使用

package heima_day16;

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

public class Demo9_AsList {
	/**
	 * A:案例演示
	* Arrays工具类的asList()方法的使用
	* Collection中toArray(T[] a)泛型版的集合转数组
	 */
	public static void main(String[] args) {
		String[] arr = {"a","b","c","d"};
		List<String> list = Arrays.asList(arr);//将数组转换为集合
		System.out.println(list);
		//数组转换成集合虽然不能增加或减少元素
		//list.add("d");
		//但是可以使用集合的思想操作数组，也就是说可以使用其他集合中的方法
	
		int[] arr1 = {11,22,33,44,55};
		List<int[]> list1 = Arrays.asList(arr1);//基本数据类型的数组转换成集合，会将整个数组当作一个整体
		System.out.println(list1);
		
		Integer[] arr2 = {11,22,33,44,55};
		List<Integer> list2 = Arrays.asList(arr2);//将数组转换为集合，数组必须是引用数据类型
		System.out.println(list2);
		
		ArrayList<String> list3 = new ArrayList<String>();
		list3.add("a");
		list3.add("b");
		list3.add("c");
		list3.add("d");
		
		String[] arr3 = list3.toArray(new String[2]);//当集合转换数组时，数组长度如果小于等于集合的size时，转换后的数组长度等于size
		for (String string : list3) {//如果数组的长度大于size，分配的数组和你指定的一样
			System.out.println(string);
		}
		
	}

}