Day15Java基础学习

最新推荐文章于 2023-12-06 18:39:35 发布

小小飞鱼喵

最新推荐文章于 2023-12-06 18:39:35 发布

阅读量97

点赞数

分类专栏：基础知识点

本文链接：https://blog.csdn.net/weixin_44400192/article/details/104176915

版权

基础知识点专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Day15

集合框架（对象数组的概述和使用）
（1）案例演示
需求：我有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]);
}

主方法：
package com.heima.collection;

import com.heima.bean.Student;

public class Demo1_Array {
	/*
	 * 需求：我有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[] arr = new int[5];  			//创建基本数据类型数组
		Student[] arr = new Student[5];  	//创建引用数据类型数组
		arr[0] = new Student("张三",23); 	//创建一个学生对象，存储在数组的第一个位置
		arr[1] = new Student("李四",24);		//创建一个学生对象，存储在数组的第二个位置
		arr[2] = new Student("王五",25);
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

Student类：
package com.heima.bean;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}
	/**
	 * @param age the age to set
	 */
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {  //Alt+shift+s重写toString方法
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

（2）画图演示
*把学生数组的案例画图讲解
*数组和集合存储引用数据类型，存的都是地址值。

集合框架（集合的由来及集合继承体系图）
（1）集合的由来
数组长度是固定，当需要增加和减少元素时需要对数组重新定义，太麻烦，java内部给我们提供了集合类，能存储任意对象，长度时可以改变的，随着元素的增加而增加，随着元素的减少而减少。
（2）数组和集合的区别
区别1：
*数组既可以存储基本数据类型，又可以存储引用数据类型
*集合只能存储引用数据类型（对象），集合中也可以存储基本数据类型，但是存储的时候会自动装箱变成对象。
区别2：
*数组长度是固定的，不能自动增长。
*集合的长度时可变的，可以根据元素的增加而增长。
（3）数组和集合什么时候用？
A.如果元素个数是固定的推荐用数组
B.如果元素个数不是固定的推荐用集合
（4）集合继承体系图
集合框架（Collection集合的基本功能测试）
（1）案例演示
基本功能演示
boolean add (E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
（2）注意
collectionXxx.java使用了未检查或不安全的操作。
注意：要了解详细信息，请使用-Xlint:unchecked重新编辑
java编辑器认为该程序存在安全隐患
温馨提示：这不是编译失败，所以先不要理会，等学了泛型就知道了。

package com.heima.collection;

import java.util.ArrayList;
import java.util.Collection;

import com.heima.bean.Student;

public class Demo2_Collection {
	/*
	 * （1）	案例演示
	基本功能演示
	boolean add (E e)
	boolean remove(Object o)
	void clear()
	boolean contains(Object o)
	boolean isEmpty()
	int size()
	（2）	注意
	collectionXxx.java使用了未检查或不安全的操作。
	注意：要了解详细信息，请使用-Xlint:unchecked重新编辑
	java编辑器认为该程序存在安全隐患
	温馨提示：这不是编译失败，所以先不要理会，等学了泛型就知道了。	
	add方法如果是List集合一直都返回true,因为List集合是可以存储重复元素的；
	如果是set集合当存储重复元素时，就会返回false
	
	ArrayList的父类的父类重写了toString方法，所以，在打印对象的引用时，输出的不是Object类中toString的结果
	 */
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		//c.remove("b");						//删除指定元素
		//c.clear();                            //清空集合
		//System.out.println(c.contains("b"));	//判断是否包含
		//System.out.println(c.isEmpty());		//判断是否为空
		System.out.println(c.size());			//获取元素的个数
		System.out.println(c);
		
		
	}

	private static void demo1() {
		Collection c = new ArrayList();         //父类引用指向子类对象
		boolean b1 = c.add("abc");
		boolean b2 = c.add(true);               //对于基本数据类型，其会自动装箱new Boolean(true)
		boolean b3 = c.add(100);              
		boolean b4 = c.add(new Student("张三",23));
		boolean b5 = c.add("abc");
		
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
		System.out.println(b4);
		System.out.println(b5);
		
		System.out.println(c);
	}

}

集合框架（集合的遍历之集合转数组遍历）
（1）集合的遍历
就是依次获取集合中的每一个元素。
（2）案例演示
把集合转成数组，可以实现集合的遍历。

package com.heima.collection;

import java.util.ArrayList;
import java.util.Collection;

import com.heima.bean.Student;

public class Demo3_Collection {
	/*
	 * （1）	集合的遍历
		就是依次获取集合中的每一个元素。
		（2）案例演示
		把集合转成数组，可以实现集合的遍历。
		toArray()
	 */
	public static void main(String[] args) {
		Collection<Student> c = new ArrayList<Student>();
		c.add(new Student("张三",23));
		c.add(new Student("李四",24));
		c.add(new Student("王五",25));
		c.add(new Student("赵六",26));
		
		Object[] arr = c.toArray();          //将集合转换成数组
		for (int i = 0; i < arr.length; i++) {
			//System.out.println(arr[i]);
			Student s = (Student) arr[i];    //强制向下转型
			System.out.println(s.getName() + "..." + s.getAge());
		}
	}

	private static void demo1() {
		Collection<String> c = new ArrayList<String>();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		Object[] arr = c.toArray();        //将集合转换成数组
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
			
		}
	}

}

集合框架（Collection集合的带All功能测试）
（1）案例演示
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)

package com.heima.collection;

import java.util.ArrayList;
import java.util.Collection;


public class Demo4_Collection {
	/*
	 * Collection集合的带All功能测试
	 * 
	 * boolean addAll(Collection c)
		boolean removeAll(Collection c)
		boolean containsAll(Collection c)
		boolean retainAll(Collection c)

	 */
	public static void main(String[] args) {
		Collection<String> c1 = new ArrayList<String>(); 
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection<String> c2 = new ArrayList<String>();    //Alt + shift + r改名
		c2.add("a");
		c2.add("b");
		
		//取交集，如果调用的集合改变就返回true,如果调用的集合没有变就返回false
		boolean b = c1.retainAll(c2);		//取交集
		System.out.println(b);				
		System.out.println(c1);
	}

	private static void demo3() {
		Collection<String> c1 = new ArrayList<String>(); 
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection<String> c2 = new ArrayList<String>();    //Alt + shift + r改名
		c2.add("a");
		c2.add("b");
		
		boolean b = c1.containsAll(c2);     //判断调用的集合是否包含传入的集合
		System.out.println(b);
	}

	private static void demo2() {
		Collection<String> c1 = new ArrayList<String>(); 
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection<String> c2 = new ArrayList<String>();    //Alt + shift + r改名
		c2.add("a");
		c2.add("b");
		
		boolean b = c1.removeAll(c2);		//删除的是交集，没有交集就不删，就返回false
		System.out.println(b);
		System.out.println(c1);
	}

	private static void demo1() {
		Collection<Object> c1 = new ArrayList<Object>(); 
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		
		Collection<String> c2 = new ArrayList<String>();    //Alt + shift + r改名
		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("d");
			
		c1.addAll(c2);						//c2中的每一个元素添加到c1中
		c1.add(c2);							//将c2看成一个对象添加到c1中
		System.out.println(c1);
	}

}

集合框架（集合的遍历之迭代器遍历）
（1）迭代器概述
集合是用来存储元素，存储的元素需要查看，那么就需要迭代（遍历）
（2）案例演示
迭代器的使用
Collection c = new ArrayList();
c.add(“a”);
c.add(“b”);
c.add(“c”);
c.add(“d”);

Iterator it = c.iterator(); //获取迭代器的引用
while(it.hasNext()) {
System.out.println(it.next));
}
7. 集合框架（Collection存储自定义对象并遍历）
（1）案例演示
Collection存储自定义对象并用迭代器遍历
Collection c = new ArrayList();

c.add(new Student(“张三”,23));
c.add(new Student(“李四”,24));
c.add(new Student(“王五”,25));
c.add(new Student(“赵六”,26));
c.add(new Student(“赵六”,26));

package com.heima.collection;

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

import com.heima.bean.Student;

public class Demo5_Iterator {
	/*
	 * （1）	迭代器概述
	集合是用来存储元素，存储的元素需要查看，那么就需要迭代（遍历）

	 */
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add(new Student("张三",23));
		c.add(new Student("李四",24));
		c.add(new Student("王五",25));
		c.add(new Student("赵六",26));
		
		//获取迭代器
		Iterator it = c.iterator();
		while(it.hasNext()) {
			//System.out.println(it.next());
			Student s = (Student)it.next();
			System.out.println(s.getName() + "..." + s.getAge());
		}
	}

	private static void demo1() {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		//对于集合中的元素进行迭代（遍历）
		Iterator it = c.iterator();         //获取迭代器
		/*boolean b1 = it.hasNext();          //判断集合中是否有元素，有就返回true
		Object obj1 = it.next();
		System.out.println(b1);
		System.out.println(obj1);
		
	
		boolean b2 = it.hasNext();          //判断集合中是否有元素，有就返回true
		Object obj2 = it.next();
		System.out.println(b2);
		System.out.println(obj2);*/
		
		while(it.hasNext())	{
			System.out.println(it.next());
		}
	}

}

集合框架（迭代器的原理及源码解析）
（1）迭代器原理
*迭代器原理：迭代器是对集合进行遍历，而每一个集合内部的存储结构是不同的，所以每一个集合存和取都是不一样的，那么就需要在每一个类中定义hasNext()和next()方法，这样做是可以而的，但是会让整个集合体系显得过于臃肿，迭代器是将这样的方法向上抽取出接口，然后在每个类的内部，定义自己迭代方式，这样做的好处有二，第一规定了整个集合体系的遍历方式都是hasNext()和next()方法；第二，代码有底层内部实现，使用者不管怎么实现的，会用即可。
（2）迭代器源码解析
A. 在exlipse中ctr + shift + t 找到ArrayList类
B. Ctrl + o查找interator()方法
C. 查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
D. 查找Itr这个内部类，发现重写了Iterator中的所有抽象方法
集合框架（List集合的特有功能概述和测试）
（1） List集合的特有功能概述
Void add(int index,E,element)
E remove(int index)
E get(int index)
E set(int index,E element)

package com.heima.list;

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

public class Demo1_List {
	/*
	 * Void add(int index,E,element)
	E remove(int index)
	E get(int index)
	E set(int index,E element)

	 */

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		list.set(1, "z");   //将指定位置的元素修改
		System.out.println(list);
	}

	private static void demo4() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		//Object obj1 = list.get(1);          
		//System.out.println(obj1);
		//通过索引遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
			
		}
	}

	private static void demo3() {
		List list = new ArrayList();
		list.add(111);
		list.add(222);
		list.add(333);
		
		list.remove(111);                   //删除的时候不会自动装箱，把111当作索引了
		System.out.peintln(list)
	}

	private static void demo2() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(4,"f");  
		
		Object obj = list.remove(1);      //通过索引删除元素，将被删除的元素返回
		System.out.println(obj);
		System.out.println(list);
	}

	private static void demo1() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(4,"f");    //index<=size 并且index>=0都不会报异常
		
		//list.add(10,"z");    //当存储时使用不存在的索引时，就会出现越界异常
		System.out.println(list);
	}

}

集合框架（List集合存储学生对象并遍历）
（1）案例演示
向List集合存储学生对象并遍历
通过size()和get()方法结合使用遍历。

package com.heima.list;

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

import com.heima.bean.Student;

public class Demo2_List {
	/*
	 * 向List集合存储学生对象并遍历
	通过size()和get()方法结合使用遍历

	 */

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Student("张三",23));
		list.add(new Student("李四",24));
		list.add(new Student("王五",25));
		list.add(new Student("赵六",26));
		
		for (int i = 0; i < list.size(); i++) {
			//System.out.println(list.get(i));    //通过索引获取每一个元素
			Student s = (Student)list.get(i);
			System.out.println(s.getName() + "..." + s.getAge());
			
		}

	}

}

集合框架（并发修改异常产生的原因及解决方案）
（1）案例演示
需求：我有一个集合，请问，我想判断有没有”world”这个元素，如果有，我就添加一个”javaee”元素，请写
（2） ConcurrentModificationException出现
迭代器遍历，集合修改集合
（3）解决方案

package com.heima.list;

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

public class Demo3_List {
	/*
	 * （1）	案例演示
	需求：我有一个集合，请问，我想判断有没有”world”这个元素，如果有，我就添加一个”javaee”元素，

	 */

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");           				 //Object obj = new String();
		list.add("b");
		list.add("world");
		list.add("c");
		list.add("d");
		
		/*Iterator it = list.iterator(); 		//获取迭代器
		while(it.hasNext()) {     				//判断集合中是有元素
			String str = (String)it.next();		//向下转型
			if("world".equals(str)) {
				list.add("javaee");         	 //遍历的同时再增加元素，并发修改
			}*/
		ListIterator lit = list.listIterator();  //list集合特有的
		while(lit.hasNext()) {
			String str = (String)lit.next();		//向下转型
			if("world".equals(str)) {
				//lit.add("javaee"); 
				lit.add("javaee");
			}
		}
		
		System.out.println(list);
		}

	}

集合框架（ListIterator）
boolean hasNext()
boolean hasPrevious()
Object next()
Object previous();

package com.heima.list;

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

public class Demo4_ListIterator {
	/*
	 * 12.	集合框架（ListIterator）
	boolean hasNext()
	boolean hasPrevious()
	Object next()
	Object previous();

	 */

	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("world");
		list.add("c");
		list.add("d");
		list.add("e");
		
		ListIterator lit = list.listIterator();  //获取迭代器
		while(lit.hasNext()) {
			System.out.println(lit.next());		//向后移动
		}
		System.out.println("..........");
		
		while(lit.hasPrevious()) {
			System.out.println(lit.previous()); //向前遍历
		}
	}

}

集合框架（Vector的特有功能）
（1） Vector类概述
（2） Vector类的特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeiation elements()
（3）案例演示
Vector的迭代

package com.heima.list;

import java.util.Enumeration;
import java.util.Vector;

public class Demo5_Vector {

	public static void main(String[] args) {
		Vector v = new Vector();
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		
		Enumeration en = v.elements();    //获取枚举
		while(en.hasMoreElements()) {	  //判断集合中是否有元素
			System.out.println(en.nextElement());
		}
	}

}

集合框架（数据结构之数组和链表）
（1）数组
查询快修改也块
增删慢

（2）链表
查询慢，修改也慢
增删快
集合框架（List的三个子类的特点）
（1） List的三个子类的特点
ArrayList：
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢（线程安全的）
Vector相对LinkedList增删慢（数组结构）
LinkedList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。

Vector和ArrayList的区别：
Vector是线程安全的，效率低
ArrayList是线程不安全的，效率高
Vector和LinkedList的区别：
ArrayList底层是数组结果，查询和修改快。
LinkedList底层是链表结构的，增和删比较块，查询和修改比较慢
共同点：都是线程不安全的。
（2） List有三个儿子，我们到底使用谁呢？
查询多用ArrayList
增删多用LinkedList
如果都多用ArrayList

小小飞鱼喵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day15Java基础学习

Day15集合框架（对象数组的概述和使用）（1）案例演示需求：我有5个学生，请把这5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生的信息。Student[] arr = new Student[5];arr[0] = new Student（“张三”，23）；arr[1] = new Student（“李四”，24）；arr[2] = new Student（“王五”，...
复制链接

扫一扫