Java集合--------16

Java集合--------16,第1张

一、ArrayList集合的使用 1.1知识点

//创建ArrayList集合对象
ArrayList list = new ArrayList<>();       <>是一种泛型

泛型:是一种数据安全的做法,规定集合应该存储怎样的数据类型

为什么要在集合中添加泛型?
        方便管理

1.2ArrayList集合方法 
package com.qf.arraylist_class;

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

public class Test02 {

	public static void main(String[] args) {
		
		//创建ArrayList集合对象
		ArrayList list = new ArrayList<>();
		
		//添加元素
		list.add("椎名空");
		list.add("张三");
		list.add("天使萌");
		list.add("佐佐木希");
		list.add("古川伊织");
		list.add("京香Julia");
		
		//在指定下标上插入元素
		list.add(3, "上原亚衣");
		
		//通过下标设置元素
		list.set(1, "王五");
		
		//将newList1中所有的元素添加到list集合的末尾
		ArrayList newList1 = new ArrayList<>();
		Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加
		list.addAll(newList1);
		
		//将newList2中所有的元素添加到list集合指定下标的位置
		ArrayList newList2 = new ArrayList<>();
		Collections.addAll(newList2, "xxx","yyy","zzz","zzz");//利用集合工具类对集合进行批量添加
		list.addAll(3, newList2);
		
		//通过下标获取元素
		String name = list.get(1);
		System.out.println("通过下标获取元素:" + name);
		
		//获取元素个数
		int size = list.size();
		System.out.println("获取元素个数:" + size);
		
		//清空集合中所有的元素
		//list.clear();
		
		System.out.println("判断集合中是否有指定元素:" + list.contains("天使萌"));//true
		System.out.println("判断集合中是否有指定集合(判断包含关系):" + list.containsAll(newList1));//true
		System.out.println("判断集合中是否没有元素:" + list.isEmpty());//false (true-没有元素 false-有元素)
		
		System.out.println("获取元素在集合中第一次出现的下标:" + list.indexOf("zzz"));//5
		System.out.println("获取元素在集合中最后一次出现的下标:" + list.lastIndexOf("zzz"));//6
		
		//依据元素删除元素
		list.remove("上原亚衣");
		//依据下标删除元素
		list.remove(1);
		
		//去除交集
		list.removeAll(newList1);
		
		//保留交集
		list.retainAll(newList2);
		
		//从开始下标处(包含)截取到结束下标处(不包含),返回新的集合
		List subList = list.subList(1, 3);
		//将集合转换为数组
		Object[] array = subList.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println("---------------");
		
		//遍历1 - for循环
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("---------------");
		
		//遍历2 - foreach
		for (String element : list) {
			System.out.println(element);
		}
		
		System.out.println("---------------");
		
		//遍历3 - Iterator
		Iterator it = list.iterator();
		while(it.hasNext()){//判断是否有下一个可迭代的元素
			String next = it.next();//返回下一个元素
			System.out.println(next);
		}
		
		System.out.println("---------------");
		
		//遍历4 - ListIterator
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()) {//判断是否有下一个可迭代的元素
			String next = listIterator.next();//返回下一个元素
			System.out.println(next);
		}
	}
}
 1.3泛型市列
package com.qf.generic01;

/**
 * <> -- 泛型
 * E - element - 元素
 * T - type - 类型
 * K - key - 键
 * V - value-值
 */
public class MyArrayList {

	public void add(E e){
	}
}
package com.qf.generic01;

import java.util.ArrayList;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 需求:模拟ArrayList底层泛型的使用场景
		 * 
		 * 泛型的类型必须是引用数据类型
		 */
		
		ArrayList list = new ArrayList<>();
		list.add(100);
		
		System.out.println("---------");
		
		MyArrayList arrayList = new MyArrayList<>();
		arrayList.add(100);
	}
}
1.4泛型举例 1.4.1定义泛型方法
package com.qf.generic02;

//所有管理系统的标准
public interface ManagerSystem {

	public int add(T t);
	
	public int delete(T t);
	
}
1.4.2实现类重写接口方法 
package com.qf.generic02;

public class BookManagerSystem implements ManagerSystem{

	@Override
	public int add(Book t) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int delete(Book t) {
		// TODO Auto-generated method stub
		return 0;
	}

}
package com.qf.generic02;

public class StudentManagerSystem implements ManagerSystem{

	@Override
	public int add(Student t) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int delete(Student t) {
		// TODO Auto-generated method stub
		return 0;
	}

}
1.5泛型限定
package com.qf.generic03;

import java.util.ArrayList;

public class Test01 {

	public static void main(String[] args) {

	}
	
	//?表示任何引用类型
	public static ArrayList method01(){
		//ArrayList list = new ArrayList<>();
		//ArrayList list = new ArrayList<>();
		ArrayList list = new ArrayList<>();
		return list;
	}
	
	//? extends A (?)表示A类或A的子类
	public static ArrayList method02(){
		//ArrayList list = new ArrayList<>();
		ArrayList list = new ArrayList<>();
		
		return list;
	}
	
	//? super A (?)表示A类或A的父类
	public static ArrayList method03(){
		//ArrayList list = new ArrayList<>();
		ArrayList list = new ArrayList<>();
		return list;
	}
}
 
 二、迭代 
2.1遍历集合  

foreach底层由迭代器实现 

package com.qf.iterator;

import java.util.ArrayList;

public class Test01 {

	public static void main(String[] args) {
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		for (String element : list) {
			System.out.println(element);
		}
		
		
		//foreach底层
//		String element;
//		for(Iterator it = list.iterator();it.hasNext();System.out.println(element)){
//			element = it.next();
//		}
		
	}
}
 2.2Iterator遍历集合
package com.qf.iterator;

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

public class Test02 {

	public static void main(String[] args) {

		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String element = it.next();
			System.out.println(element);
		}
	}
}
 2.3Iterator遍历集合到某某值时删除该值
package com.qf.iterator;

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

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点:Iterator
		 * 
		 * 需求:使用Iterator遍历集合,在遍历到"椎名空"是删除该元素
		 * 
		 * 总结:Iterator可以遍历集合时删除
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String element = it.next();
			if(element.equals("椎名空")){
				
				//ConcurrentModificationException - 当前修改异常
				//报错原因:ArrayList的 *** 作数 和 Itr的 *** 作数不一致
				//设计思想:使用迭代器是遍历数据,如果你在遍历时 *** 作数据,会导致遍历数据有误,严谨在遍历时使用集合删除元素,要删除都是使用的迭代器删除元素
				//list.remove(element);
			
				it.remove();
			}
		}
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}
 2.4ListIterator遍历集合
package com.qf.iterator;

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

public class Test04 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator遍历集合
		 * 
		 * 总结:ListIterator可以像Iterator一样遍历集合
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String next = listIterator.next();
			System.out.println(next);
		}
	}
}
2.5使用ListIterator遍历集合,遍历到某某元素时删除元素
package com.qf.iterator;

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

public class Test05 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator遍历集合,遍历到"椎名空"时删除元素
		 * 
		 * 总结:ListIterator可以像Iterator一样遍历集合时删除元素
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String next = listIterator.next();
			if(next.equals("椎名空")){
				listIterator.remove();
			}
		}
		
		for (String str : list) {
			System.out.println(str);
		}
	}
}
 2.6使用ListIterator遍历集合,遍历到某某元素时添加元素
package com.qf.iterator;

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

public class Test06 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator遍历集合,遍历到"椎名空"时添加元素
		 * 
		 * 总结:ListIterator可以在遍历集合时添加元素
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String next = listIterator.next();
			if(next.equals("椎名空")){
				listIterator.add("罗菌鱼");
			}
		}
		
		for (String str : list) {
			System.out.println(str);
		}
	}
}
 2.7使用ListIterator遍历集合,遍历到某某元素时替换元素
package com.qf.iterator;

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

public class Test07 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator遍历集合,遍历到"椎名空"时替换元素
		 * 
		 * 总结:ListIterator可以在遍历集合时替换元素
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()){
			String next = listIterator.next();
			if(next.equals("椎名空")){
				listIterator.set("罗菌鱼");
			}
		}
		
		for (String str : list) {
			System.out.println(str);
		}
	}
}
 2.8使用ListIterator实现指定下标开始遍历集合
package com.qf.iterator;

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

public class Test08 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator实现指定下标开始遍历集合
		 * 
		 * 总结:ListIterator可以指定下标开始遍历
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator(1);
		while(listIterator.hasNext()){
			String next = listIterator.next();
			System.out.println(next);
		}
		
	}
}
2.9使用ListIterator实现倒叙遍历集合
package com.qf.iterator;

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

public class Test09 {

	public static void main(String[] args) {
		/**
		 * 知识点:ListIterator
		 * 
		 * 需求:使用ListIterator实现倒叙遍历集合
		 * 
		 * 总结:ListIterator可以实现倒叙遍历集合
		 */
		
		ArrayList list = new ArrayList<>();
	
		list.add("麻生希");
		list.add("椎名空");
		list.add("天使萌");
		list.add("爱田奈奈");
	
		ListIterator listIterator = list.listIterator(list.size());
		while(listIterator.hasPrevious()){//判断是否有上一个可迭代的元素
			String previous = listIterator.previous();//获取上一个元素
			System.out.println(previous);
		}
		
		/**
		 * Iterator vs ListIterator
		 * 
		 * Iterator:正序遍历、删除元素
		 * ListIterator:正序遍历、指定下标开始遍历、倒叙遍历、删除元素、添加元素、替换元素
		 * 
		 * 注意:List接口下的实现类才能获取ListIterator
		 */
	}
}
 3.0 LinkedList之队列模式
package com.qf.linkedlist_class;

import java.util.LinkedList;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点:LinkedList 之 队列模式
		 * 
		 * 队列模式:先进先出
		 */
		
		LinkedList list = new LinkedList<>();
		
		list.add("罗非鱼1");
		list.add("罗非鱼2");
		list.add("罗非鱼3");
		list.add("罗非鱼4");
		list.add("罗非鱼5");
		
		while(!list.isEmpty()){//判断集合中是否有元素
			//删除第一个元素,并返回
			String element = list.removeFirst();
			System.out.println(element);
		}
		
		System.out.println("集合中的元素个数:" + list.size());//0
	}
}
 3.1LinkedList 之栈模式
package com.qf.linkedlist_class;

import java.util.LinkedList;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点:LinkedList 之栈模式
		 * 
		 * 栈模式:先进后出/后进先出
		 */
		
		LinkedList list = new LinkedList<>();
		
		list.add("罗菌鱼1");
		list.add("罗菌鱼2");
		list.add("罗菌鱼3");
		list.add("罗菌鱼4");
		list.add("罗菌鱼5");
		
		while(!list.isEmpty()){//判断集合中是否有元素
			//删除最后一个元素,并返回
			String element = list.removeLast();
			System.out.println(element);
		}
		
		System.out.println("集合中的元素个数:" + list.size());//0
	}
}
 3.2HashSet
package com.qf.hashset_class;

import java.util.HashSet;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点:理解HashSet的无序且不可重复
		 * 
		 * 存入顺序:
		 * 		1.获取对象的hash值 -- hashCode()
		 * 		2.通过散列算法计算出在数组中的下标
		 * 			2.1 下标上没有元素 --- 直接加入
		 * 			2.2 下标上有元素 - 判断两个对象是否相同(hash、==、equals)
		 * 				2.2.1 相同对象,不存(达到去重的效果)
		 * 				2.2.2 不同对象,就存储
		 * 取出顺序:
		 * 		从头到尾遍历数组
		 */
		
		HashSet set = new HashSet<>();
		
		set.add("罗志祥");
		set.add("张柏芝");
		set.add("阿娇");
		set.add("陈冠希");
		set.add("吴亦凡");
		set.add("吴亦凡");
		
		for (String str : set) {
			System.out.println(str);
		}
	}
}
 3.3Vector
package com.qf.vector_class;

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

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点:Vector的发展史
		 * 
		 * Vector是JDK1.0就有的集合类(元老级别的类),但是还没有集合框架的概念
		 * JDK1.2才开始推广集合框架的概念,当时大部分程序员习惯使用Vector,所以Java又给Vector多实现了一个接口(List)
		 * 所以才将其保留下来,所以Vector类中有很多老的方法(这些方法很喜欢使用element来命名)
		 * 
		 * Vector是一个线程安全的类
		 */
		
		Vector v = new Vector<>();
		
		v.addElement("张三1");
		v.addElement("张三2");
		v.addElement("张三3");
		v.addElement("张三4");
		v.addElement("张三5");
		v.addElement("张三6");
		
		v.removeElementAt(1);//根据下标删除元素
		v.removeElement("李林俊6");//根据元素删除元素
		
		Enumeration elements = v.elements();
		while(elements.hasMoreElements()){
			String nextElement = elements.nextElement();
			System.out.println(nextElement);
		}
		
	}
}
 3.4Stack
package com.qf.stack_class;

import java.util.Stack;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:Stack
		 * 特点:栈模式 - 先进后出
		 * 
		 * class Stack extends Vector
		 */
		
		Stack stack = new Stack<>();
		
		//将元素压入栈顶
		stack.push("李林俊1");
		stack.push("李林俊2");
		stack.push("李林俊3");
		stack.push("李林俊4");
		stack.push("李林俊5");
		
		//获取栈顶元素
		String peek = stack.peek();
		System.out.println(peek);//李林俊5
		
		//删除栈顶元素,并返回
		//String pop = stack.pop();
		//System.out.println(pop);//李林俊5
		
		//查看该元素距离栈顶位置(从1开始)
		int search = stack.search("李林俊1");
		System.out.println("查看该元素距离栈顶位置(从1开始):" + search);
	
		//遍历
		while(!stack.empty()){//有元素-false  没有元素-true
			String pop = stack.pop();
			System.out.println(pop);
		}
	
	
	}
}

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/905317.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-15
下一篇 2022-05-15

发表评论

登录后才能评论

评论列表(0条)