Day13学习Java

最新推荐文章于 2024-08-12 23:09:11 发布
最新推荐文章于 2024-08-12 23:09:11 发布
阅读量699 收藏 10
点赞数 16
文章标签： 学习 java windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45621552/article/details/138890786
版权

深入迭代器 -- foreach

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    for (String element : list) {
        System.out.println(element);
    }
        
    /**
     * 使用foreach循环遍历集合的底层实现：
     *      String element;
            for(Iterator it = list.iterator();it.hasNext();System.out.println(element))
                element = (String) it.next();
     */
}

深入迭代器 -- Iterator

深入：Iterator如何遍历元素

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    list.remove("bbb");
        
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String element = it.next();
        System.out.println(element);
    }
}

需求：使用Iterator遍历元素，遍历到"bbb"时删除该元素

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
    //modCount - 5
        
    //expectedModCount - 5
    Iterator<String> it = list.iterator();
        
    while(it.hasNext()){
            
        it.remove();
            
        String element = it.next();
        if(element.equals("bbb")){
            //list.remove(element);//modCount - 6
            it.remove();
        }
    }
        
    for (String element : list) {
        System.out.println(element);
    }
}

深入迭代器 -- ListIterator

需求：使用ListIterator遍历元素

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    ListIterator<String> listIterator = list.listIterator();
    while(listIterator.hasNext()){
        String element = listIterator.next();
        System.out.println(element);
    }
}

需求：使用ListIterator遍历元素，遍历到"bbb"时删除

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
    
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    ListIterator<String> listIterator = list.listIterator();
    while(listIterator.hasNext()){
        String element = listIterator.next();
        if(element.equals("bbb")){
            listIterator.remove();
        }
    }
        
    for (String element : list) {
        System.out.println(element);
    }
}

需求：使用ListIterator遍历元素，遍历到"bbb"时添加"xyz"

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    ListIterator<String> listIterator = list.listIterator();
    while(listIterator.hasNext()){
        String element = listIterator.next();
        if(element.equals("bbb")){
            listIterator.add("xyz");
        }
    }
        
    for (String element : list) {
        System.out.println(element);
    }
}

需求：使用ListIterator指定下标遍历元素

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    ListIterator<String> listIterator = list.listIterator(1);
    while(listIterator.hasNext()){
        String element = listIterator.next();
        System.out.println(element);
    }
}

需求：使用ListIterator倒序遍历元素

public static void main(String[] args) {
        
    ArrayList<String> list = new ArrayList<>();
        
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    list.add("eee");
        
    ListIterator<String> listIterator = list.listIterator(list.size());
    while(listIterator.hasPrevious()){
        String element = listIterator.previous();
        System.out.println(element);
    }
}

< E > 创建对象时规定类型

  • E - element - 元素

  • T - Type - 类型

  • 注意：设置泛型可以有多个

  • <K,V>

  • K - Key 键

  • V - Value 值

  • <N,V>

  • N - name 名

  • V - Value 值

泛型在集合中的使用

public static void main(String[] args) {
		
	ArrayList<Integer> list = new ArrayList<>();
		
	list.add(100);
	list.add(100);
	list.add(100);
		
	System.out.println("-----------------------------");
		
	MyArrayList<Integer> myArrayList = new MyArrayList<>();
		
	myArrayList.add(100);
	myArrayList.add(100);
	myArrayList.add(100);
}

泛型限定

继承关系：Object.A.B

public static void main(String[] args) {
				
}
	
//?表示任意类型
public static ArrayList<?> method01(){
		
//	ArrayList<Object> list = new ArrayList<>();
//	ArrayList<A> list = new ArrayList<>();
	ArrayList<B> list = new ArrayList<>();
	return list; 
}
	
//? extends A 表示A类型或者是A的子类类型
public static ArrayList<? extends A> method02(){
			
//	ArrayList<A> list = new ArrayList<>();
	ArrayList<B> list = new ArrayList<>();
	return list; 
}
	
//? super A 表示A类型或者是A的父类类型
public static ArrayList<? super A> method03(){
			
//	ArrayList<A> list = new ArrayList<>();
	ArrayList<Object> list = new ArrayList<>();
	return list; 
}
package com.qf.generic02;

public class A {

}
package com.qf.generic02;
//此处B继承A
public class B extends A{

}

ArrayList的使用

public static void main(String[] args) {
		
	ArrayList<String> list = new ArrayList<>();
		
	//添加数据
	list.add("麻生希");
	list.add("椎名空");
	list.add("水菜丽");
	list.add("朝桐光");
	list.add("樱井步");
		
	//设置指定下标上的元素
	list.set(1, "侯小康");
		
	//获取指定下标上的元素
	String str = list.get(1);
	System.out.println("获取指定下标上的元素：" + str);//侯小康
		
	//获取元素个数
	int size = list.size();
	System.out.println("获取元素个数：" + size);//5
		
	//在指定下标上添加元素
	list.add(2, "杨雪飞");
		
	ArrayList<String> newList1 = new ArrayList<>();
	Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
	list.addAll(newList1);//将newList1中所有的元素都添加到list集合里末尾的位置
		
	ArrayList<String> newList2 = new ArrayList<>();
	Collections.addAll(newList2, "xxx","xxx","yyy","yyy","zzz","zzz");//利用集合工具类（Collections）批量添加元素
	list.addAll(3, newList2);//将newList2中所有的元素都添加到list集合里指定下标的位置
		
	//清空集合里所有的元素
	//list.clear();
		
	System.out.println("判断集合中是否包含指定元素：" + list.contains("侯小康"));//true
	System.out.println("判断集合中是否包含指定集合：" + list.containsAll(newList1));//true
		
	System.out.println("获取元素在集合中第一次出现的下标：" + list.indexOf("ccc"));//12
	System.out.println("获取元素在集合中最后一次出现的下标：" + list.lastIndexOf("ccc"));//13
		
	//没有-true，有-false
	System.out.println("判断集合里是否没有元素：" + list.isEmpty());//false
		
	list.remove(9);//通过下标删除元素
	list.remove("水菜丽");//通过数据删除元素
	list.removeAll(newList1);//将list中有newList1的元素全部删除(去除交集)
		
	list.retainAll(newList2);//将list中有newList2的元素全部保留(保留交集)
		
	List<String> subList = list.subList(1, 4);//从开始下标处(包含)截取到结束下标处(排他)的元素，返回新的集合
		
	//将集合转换为数组
	Object[] array1 = subList.toArray();
		System.out.println(Arrays.toString(array1));//[xxx, yyy, yyy]
		
	//将集合转换为指定类型的数组
	String[] array2 = new String[3];
	subList.toArray(array2);
		System.out.println(Arrays.toString(array2));//[xxx, yyy, yyy]
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- for循环
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
		
	System.out.println("-----------------------------------------");
	
	//遍历集合 -- foreach
	for (String element : list) {
		System.out.println(element);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- Iterator
	Iterator<String> it = list.iterator();
	while(it.hasNext()){//判断是否有可迭代的元素
		String next = it.next();//获取下一个元素
		System.out.println(next);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- ListIterator
	ListIterator<String> listIterator = list.listIterator();
	while(listIterator.hasNext()){//判断是否有可迭代的元素
		String next = listIterator.next();//获取下一个元素
		System.out.println(next);
	}	
}

HashSet的使用

public static void main(String[] args) {
		
	HashSet<String> set = new HashSet<>();
		
	//添加数据
	set.add("麻生希");
	set.add("椎名空");
	set.add("水菜丽");
	set.add("朝桐光");
	set.add("樱井步");
		
	//获取元素个数
	int size = set.size();
	System.out.println("获取元素个数：" + size);//5
		
	HashSet<String> newSet1 = new HashSet<>();
	Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
	set.addAll(newSet1);//将newSet1中所有的元素都添加到set集合里
		
	//清空集合里所有的元素
	//set.clear();
		
	System.out.println("判断集合中是否包含指定元素：" + set.contains("侯小康"));//false
	System.out.println("判断集合中是否包含指定集合：" + set.containsAll(newSet1));//true
	
	//没有-true，有-false
	System.out.println("判断集合里是否没有元素：" + set.isEmpty());//false
		
	set.remove("水菜丽");//通过数据删除元素
	set.removeAll(newSet1);//将set中有newSet1的元素全部删除(去除交集)
		
	HashSet<String> newSet2 = new HashSet<>();
	Collections.addAll(newSet2, "麻生希","水菜丽","樱井步");
	set.retainAll(newSet2);//将set中有newSet2的元素全部保留(保留交集)
		
	//将集合转换为数组
	Object[] array1 = set.toArray();
		System.out.println(Arrays.toString(array1));//[樱井步, 麻生希]
		
	//将集合转换为指定类型的数组
	String[] array2 = new String[2];
	set.toArray(array2);
		System.out.println(Arrays.toString(array2));//[樱井步, 麻生希]
		
	System.out.println("-----------------------------------------");
 
	//遍历集合 -- foreach
	for (String element : set) {
		System.out.println(element);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- Iterator
	Iterator<String> it = set.iterator();
	while(it.hasNext()){//判断是否有可迭代的元素
		String next = it.next();//获取下一个元素
		System.out.println(next);
	}	
}

HashSet的特点

特点：无序且去重

添加步骤：

1.获取元素的hash值 -- hashCode()

2.通过hash值计算在数组中的下标

3.判断下标上是否有元素

3.1 没有元素 -- 直接添加

3.2 有元素 ---- 判断两个对象是否相同 hash && (==||equals())

3.2.1 相同 -- 不添加数据(达到去重效果)

3.2.2 不相同 -- 形成单向链表（JDK1.7头插法、JDK1.8尾插法）

遍历步骤：

遍历数组（顺序遍历）

注意：添加步骤处理数据的逻辑和遍历步骤处理数据的逻辑不一样，导致无序。

LinkedHashSet的使用

public static void main(String[] args) {
		
	LinkedHashSet<String> set = new LinkedHashSet<>();
		
	//添加数据
	set.add("麻生希");
	set.add("椎名空");
	set.add("水菜丽");
	set.add("朝桐光");
	set.add("樱井步");
		
	//获取元素个数
	int size = set.size();
	System.out.println("获取元素个数：" + size);//5
		
	LinkedHashSet<String> newSet1 = new LinkedHashSet<>();
	Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
	set.addAll(newSet1);//将newSet1中所有的元素都添加到set集合里
		
	//清空集合里所有的元素
	//set.clear();
		
	System.out.println("判断集合中是否包含指定元素：" + set.contains("侯小康"));//false
	System.out.println("判断集合中是否包含指定集合：" + set.containsAll(newSet1));//true
		
	//没有-true，有-false
	System.out.println("判断集合里是否没有元素：" + set.isEmpty());//false
		
	set.remove("水菜丽");//通过数据删除元素
	set.removeAll(newSet1);//将set中有newSet1的元素全部删除(去除交集)
		
	LinkedHashSet<String> newSet2 = new LinkedHashSet<>();
	Collections.addAll(newSet2, "麻生希","水菜丽","樱井步");
	set.retainAll(newSet2);//将set中有newSet2的元素全部保留(保留交集)
		
	//将集合转换为数组
	Object[] array1 = set.toArray();
		System.out.println(Arrays.toString(array1));//[樱井步, 麻生希]
		
	//将集合转换为指定类型的数组
	String[] array2 = new String[2];
	set.toArray(array2);
		System.out.println(Arrays.toString(array2));//[樱井步, 麻生希]
		
	System.out.println("-----------------------------------------");
 
	//遍历集合 -- foreach
	for (String element : set) {
		System.out.println(element);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- Iterator
	Iterator<String> it = set.iterator();
	while(it.hasNext()){//判断是否有可迭代的元素
		String next = it.next();//获取下一个元素
		System.out.println(next);
	}	
}

LinkedHashSet的特点

继承关系：class LinkedHashSet extends HashSet

特点：有序且去重

添加步骤： 在父类HashSet的基础上，添加的元素会存储上一个元素的地址，上一个元素也会存储下一个元素的地址 -- 双向链表

遍历步骤： 找到第一个元素，再向下依次找下一个元素

LinkedList的使用

public static void main(String[] args) {
		
	LinkedList<String> list = new LinkedList<>();
		
	//添加数据
	list.add("麻生希");
	list.add("椎名空");
	list.add("水菜丽");
	list.add("朝桐光");
	list.add("樱井步");
		
	//设置指定下标上的元素
	list.set(1, "侯小康");
		
	//获取指定下标上的元素
	String str = list.get(1);
	System.out.println("获取指定下标上的元素：" + str);//侯小康
		
	//获取元素个数
	int size = list.size();
	System.out.println("获取元素个数：" + size);//5
		
	//在指定下标上添加元素
	list.add(2, "杨雪飞");
		
	LinkedList<String> newList1 = new LinkedList<>();
	Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
	list.addAll(newList1);//将newList1中所有的元素都添加到list集合里末尾的位置
		
	LinkedList<String> newList2 = new LinkedList<>();
	Collections.addAll(newList2, "xxx","xxx","yyy","yyy","zzz","zzz");//利用集合工具类（Collections）批量添加元素
	list.addAll(3, newList2);//将newList2中所有的元素都添加到list集合里指定下标的位置
		
	//清空集合里所有的元素
	//list.clear();
		
	System.out.println("判断集合中是否包含指定元素：" + list.contains("侯小康"));//true
	System.out.println("判断集合中是否包含指定集合：" + list.containsAll(newList1));//true
		
	System.out.println("获取元素在集合中第一次出现的下标：" + list.indexOf("ccc"));//12
	System.out.println("获取元素在集合中最后一次出现的下标：" + list.lastIndexOf("ccc"));//13
		
	//没有-true，有-false
	System.out.println("判断集合里是否没有元素：" + list.isEmpty());//false
		
	list.remove(9);//通过下标删除元素
	list.remove("水菜丽");//通过数据删除元素
	list.removeAll(newList1);//将list中有newList1的元素全部删除(去除交集)
	
	list.retainAll(newList2);//将list中有newList2的元素全部保留(保留交集)
		
	List<String> subList = list.subList(1, 4);//从开始下标处(包含)截取到结束下标处(排他)的元素，返回新的集合
		
	//将集合转换为数组
	Object[] array1 = subList.toArray();
		System.out.println(Arrays.toString(array1));//[xxx, yyy, yyy]
		
	//将集合转换为指定类型的数组
	String[] array2 = new String[3];
	subList.toArray(array2);
		System.out.println(Arrays.toString(array2));//[xxx, yyy, yyy]
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- for循环
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- foreach
	for (String element : list) {
		System.out.println(element);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- Iterator
	Iterator<String> it = list.iterator();
	while(it.hasNext()){//判断是否有可迭代的元素
		String next = it.next();//获取下一个元素
		System.out.println(next);
	}
		
	System.out.println("-----------------------------------------");
	
	//遍历集合 -- ListIterator
	ListIterator<String> listIterator = list.listIterator();
	while(listIterator.hasNext()){//判断是否有可迭代的元素
		String next = listIterator.next();//获取下一个元素
		System.out.println(next);
	}			
}

LinkedList独有的方法

public static void main(String[] args) {
		
	LinkedList<String> list = new LinkedList<>();
		
	list.add("麻生希1");
	list.add("麻生希2");
	list.add("麻生希3");
	list.add("abc");
	list.add("abc");
	list.add("AAA");
	list.add("abc");
	list.add("abc");
		
	//添加到头部
	list.addFirst("aaa");
	list.offerFirst("bbb");
	list.push("ccc");
		
	//添加到末尾
	list.addLast("xxx");
	list.offer("yyy");
	list.offerLast("zzz");
		
	System.out.println("获取第一个元素：" + list.element());
	System.out.println("获取第一个元素：" + list.getFirst());
	System.out.println("获取第一个元素：" + list.peek());
	System.out.println("获取第一个元素：" + list.peekFirst());
	System.out.println("获取第一个元素：" + list.pop());
		
	System.out.println("获取最后一个元素：" + list.getLast());
	System.out.println("获取最后一个元素：" + list.peekLast());
		
	//删除第一个元素
	list.poll();
	list.pollFirst();
	list.removeFirst();
		
	//删除最后一个元素
	list.pollLast();
	list.removeLast();
		
	//删除第一次出现的元素
	list.removeFirstOccurrence("abc");
		
	//删除最后一次出现的元素
	list.removeLastOccurrence("abc");
		
	//倒序遍历
	Iterator<String> descendingIterator = list.descendingIterator();
	while(descendingIterator.hasNext()){
		String next = descendingIterator.next();
		System.out.println(next);
	}
		
	for (String element : list) {
		System.out.println(element);
	}	
}

LikedList实现队列模式

注意：队列模式 - 先进先出

public static void main(String[] args) {
		
	LinkedList<String> list = new LinkedList<>();
		
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	list.add("ddd");
	list.add("eee");
		
	while(!list.isEmpty()){
		//String element = list.pollFirst();
		String element = list.removeFirst();
		System.out.println(element);
	}
		
	System.out.println("集合的元素个数为：" + list.size());//0
}

注意：栈模式 - 先进后出/后进先出

public static void main(String[] args) {
		
	LinkedList<String> list = new LinkedList<>();
		
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	list.add("ddd");
	list.add("eee");
		
	while(!list.isEmpty()){
		String element = list.removeLast();
		System.out.println(element);
	}
		
	System.out.println("集合的元素个数为：" + list.size());//0
}

Stack的使用

继承关系：class Stack extends Vector 特点：栈模式

public static void main(String[] args) {
		
	Stack<String> stack = new Stack<>();
		
	//将元素添加到栈顶
	stack.push("aaa");
	stack.push("bbb");
	stack.push("ccc");
	stack.push("ddd");
	stack.push("eee");
		
	System.out.println("获取栈顶元素：" + stack.peek());
	System.out.println("获取元素到栈顶的距离：" + stack.search("bbb"));//4 - 从1开始数
		
	//判断集合是否为空内容
	while(!stack.empty()){
			
		//删除栈顶元素，并返回
		String pop = stack.pop();
		System.out.println(pop);
	}	
}

Vector的使用

public static void main(String[] args) {
		
	Vector<String> list = new Vector<>();
		
	//添加数据
	list.add("麻生希");
	list.add("椎名空");
	list.add("水菜丽");
	list.add("朝桐光");
	list.add("樱井步");
		
	//设置指定下标上的元素
	list.set(1, "侯小康");
		
	//获取指定下标上的元素
	String str = list.get(1);
	System.out.println("获取指定下标上的元素：" + str);//侯小康
		
	//获取元素个数
	int size = list.size();
	System.out.println("获取元素个数：" + size);//5
		
	//在指定下标上添加元素
	list.add(2, "杨雪飞");
		
	Vector<String> newList1 = new Vector<>();
	Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类（Collections）批量添加元素
	list.addAll(newList1);//将newList1中所有的元素都添加到list集合里末尾的位置
		
	Vector<String> newList2 = new Vector<>();
	Collections.addAll(newList2, "xxx","xxx","yyy","yyy","zzz","zzz");//利用集合工具类（Collections）批量添加元素
	list.addAll(3, newList2);//将newList2中所有的元素都添加到list集合里指定下标的位置
		
	//清空集合里所有的元素
	//list.clear();
		
	System.out.println("判断集合中是否包含指定元素：" + list.contains("侯小康"));//true
	System.out.println("判断集合中是否包含指定集合：" + list.containsAll(newList1));//true
		
	System.out.println("获取元素在集合中第一次出现的下标：" + list.indexOf("ccc"));//12
	System.out.println("获取元素在集合中最后一次出现的下标：" + list.lastIndexOf("ccc"));//13
		
	//没有-true，有-false
	System.out.println("判断集合里是否没有元素：" + list.isEmpty());//false
		
	list.remove(9);//通过下标删除元素
	list.remove("水菜丽");//通过数据删除元素
	list.removeAll(newList1);//将list中有newList1的元素全部删除(去除交集)
		
	list.retainAll(newList2);//将list中有newList2的元素全部保留(保留交集)
		
	List<String> subList = list.subList(1, 4);//从开始下标处(包含)截取到结束下标处(排他)的元素，返回新的集合
		
	//将集合转换为数组
	Object[] array1 = subList.toArray();
		System.out.println(Arrays.toString(array1));//[xxx, yyy, yyy]
		
	//将集合转换为指定类型的数组
	String[] array2 = new String[3];
	subList.toArray(array2);
		System.out.println(Arrays.toString(array2));//[xxx, yyy, yyy]
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- for循环
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- foreach
	for (String element : list) {
		System.out.println(element);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- Iterator
	Iterator<String> it = list.iterator();
	while(it.hasNext()){//判断是否有可迭代的元素
		String next = it.next();//获取下一个元素
		System.out.println(next);
	}
		
	System.out.println("-----------------------------------------");
		
	//遍历集合 -- ListIterator
	ListIterator<String> listIterator = list.listIterator();
	while(listIterator.hasNext()){//判断是否有可迭代的元素
		String next = listIterator.next();//获取下一个元素
		System.out.println(next);
	}	
}

Vector老的方法

理解：Vector属于元老级别的集合类(JDK1.0)，JDK1.2开始才有集合框架的概念，为了将Vector保留下来，Java的设计者让Vector多实现了List接口。

public static void main(String[] args) {
		
	Vector<String> v = new Vector<>();
		
	v.addElement("aaa");
	v.addElement("bbb");
	v.addElement("ccc");
	v.addElement("ddd");
	v.addElement("eee");
		
	v.removeElementAt(0);//根据下标删除元素
	v.removeElement("bbb");//根据数据删除元素
		
	Enumeration<String> elements = v.elements();
	while(elements.hasMoreElements()){
		String nextElement = elements.nextElement();
		System.out.println(nextElement);
	}
}

List接口下的集合 ---------------------------------------------------

ArrayList 数据结构：一维数组 特点：存储数据 LinkedList 数据结构：双向列表 特点：队列模式、栈模式

Vector 数据结构：一维数组 特点：线程安全 Stack 继承关系：class Stack extends Vector 特点：栈模式 Set接口下的集合 ------------------------------------------------------

HashSet 数据结构：hash表（一维数组） 特点：无序且不可重复

LinkedHashSet 继承关系：class LinkedHashSet extends HashSet 特点：有序且去重（添加了双向链表的数据结构）

TreeSet 数据结构：

二叉树 特点：根据元素类型自然排序

阿船·
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习路线：day13
01-20
文章目录第四章 面向对象(中)面向对象特征之三：多态性向下转型的使用多态性的练习Object 类的使用Object类中的主要结构==操作符与equals方法重写equals()方法的原则toString的使用包装类(Wrapper)的使用单元测试...
Java学习day01-day15学习资料
04-05
这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这部分可能涉及Java的基础语法，如变量、数据类型、运算符、流程控制语句...
Java学习打卡day13
lianfenxie的博客
03-29 169
【代码】Java学习打卡day13。
JAVA学习DAY1
weixin_47848121的博客
04-22 333
1.数据库SQL语言学习（3h）4.计算机网络（0.8h）2.华为测评（1h）
java后端学习DAY04
2302_76786736的博客
04-12 348
JAVAGUIDE：java基础常见面试总结（上）
Java后端学习DAY06
2302_76786736的博客
04-16 314
湖科大计网第3章。
Java学习打卡day7
lianfenxie的博客
03-23 367
【代码】Java学习打卡day7。
Java学习打卡day18
lianfenxie的博客
04-03 190
【代码】Java学习打卡day18。
Java学习打卡day5
lianfenxie的博客
03-21 160
【代码】Java学习打卡day5。
java学习打卡day4
lianfenxie的博客
03-20 138
【代码】java学习打卡day4。
java学习day01
Frozac的博客
07-04 708
#本人刚刚踏入java培训，想借着写写博客来总结下每天的学习内容，希望给自学的朋友有点帮助Android:四大组件 Bluetooth wifi cocos2d(重力)Linux: 10大经典命令 tftp(上传和下载) Shell编程标准版 J2SE (Java 2 Platform Standard Edition) 面向对象编程 企业版 J2EE (Java 2 Platform Enterprise Edition) Web编程 微缩版 J2ME (Java 2 Platform Micro Edi
day13_java_源码
10-04
本文将深入探讨这两个概念，并结合"day13_java_源码"提供的实例，帮助初学者理解如何在实际开发中运用它们。 1. **抽象类**： 抽象类是不能被实例化的类，它主要用来定义一个类的基本结构和行为。在Java中，使用`...
java学习day06
01-20
面向对象 public class Demo01PrintArray { public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; // 使用面向过程 System.out.print([);//去掉ln,不换行 for (int i = 0;...
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
【鸿蒙学习】Stage模型与FA模型的对比与应用选择
最新发布
一个不断前行的程序者
08-12 234
Stage模型是一种基于应用生命周期和功能模块划分的架构设计理念。它将应用分为多个阶段（Stage），每个阶段对应一个特定的任务或界面，使得应用结构更加清晰、开发更加高效。FA模型（Feature Ability Model）是鸿蒙OS中另一种应用架构设计理念，它以功能为单元，将应用划分为多个功能模块（Feature Ability），每个模块具有独立的生命周期和功能。Stage模型和FA模型各有优势，适用于不同的开发场景。普通开发者应根据项目需求、团队协作、性能要求等因素，选择最合适的模型。
车身域测试学习、CANoe工具实操学习、UDS诊断测试、功能安全测试、DTC故障注入测试、DBC数据库、CDD数据库、CAN一致性测试
车载测试
08-12 481
车身域测试学习、CANoe工具实操学习、UDS诊断测试、功能安全测试、DTC故障注入测试、DBC数据库、CDD数据库、CAN一致性测试
日常学习--20240806
xxm13679073037的博客
08-07 817
调优
【IC设计】昇腾910架构学习
VICI的博客
08-10 259
昇腾910是华为的AI训练卡，基于7nm EUV工艺，其中有16个基于ARMv8定制的CPU，32个Ascend-Max AI加速器，使用4*6的无缓存NoC Mesh进行互联，使用HBM（High Bandwidth Memory）进行存储，提供128通道的视频译码器。本文内容是参考华为公开资料形成的个人观点，无侵权行为，内容仅供学习！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值