JAVA 基础知识整理-12（集合类）Vector, LinkedList, 泛型，增强for循环

最新推荐文章于 2022-04-06 06:30:46 发布
最新推荐文章于 2022-04-06 06:30:46 发布
阅读量164 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KathyLJQ/article/details/104739891
版权

1. Vector 类

主要方法：

void addElement(E obj)
将指定的组件添加到此向量的末尾，且向量的大小加 1。
E elementAt(int index)
返回指定索引处的组件。
Enumeration elements()
返回此向量的组件的枚举。

Enumeration的主要方法：

boolean hasMoreElements()
测试此枚举是否包含更多的元素。
E nextElement()
如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

代码示例：

package testdemo;

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

public class ArrayListDemo {
	public static void main(String[] args) {
		Vector v = new Vector();
		Student s1 = new Student("jimm",20);
		Student s2 = new Student("linda",25);
		Student s3 = new Student("dotta",28);
		v.addElement(s1);
		v.addElement(s2);
		v.addElement(s3);
		System.out.println(v);
		System.out.println(v.elementAt(0));
		Enumeration e = v.elements();
		while(e.hasMoreElements()){
			System.out.println(e.nextElement());
		}
	
	}
}
输出：
[Student name=jimm, age=20, Student name=linda, age=25, Student name=dotta, age=28]
Student name=jimm, age=20
Student name=jimm, age=20
Student name=linda, age=25
Student name=dotta, age=28

2. LinkedList类

LinkedList特有的方法：

void addFirst(E o)
将给定元素插入此列表的开头。
void addLast(E o)
将给定元素追加到此列表的结尾。(这个方法跟集合通用的方法add()的使用差不多）
E getFirst()
返回此列表的第一个元素。
E getLast()
返回此列表的最后一个元素。
E removeFirst()
移除并返回此列表的第一个元素。
E removeLast()
移除并返回此列表的最后一个元素。

代码示例：

package testdemo;

import java.util.LinkedList;

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList lkd = new LinkedList();
		Student s1 = new Student("jimm",20);
		Student s2 = new Student("linda",25);
		Student s3 = new Student("dotta",28);
		lkd.addFirst(s1);
		lkd.addFirst(s2);
		lkd.addFirst(s3);
		System.out.println(lkd);		
		System.out.println(lkd.getFirst());
		System.out.println(lkd.getLast());
		System.out.println(lkd.removeLast());
		System.out.println(lkd);
	}
}
输出：
[Student name=dotta, age=28, Student name=linda, age=25, Student name=jimm, age=20]
Student name=dotta, age=28
Student name=jimm, age=20
Student name=jimm, age=20
[Student name=dotta, age=28, Student name=linda, age=25]

ArrayList去重（选择排序法）

package testdemo;

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

public class RemoveDuplicateElement {
	public static void main(String[] args) {
		ArrayList arr0 = new ArrayList();
		arr0.add("hello");
		arr0.add("hello");
		arr0.add("hello");
		arr0.add("world");
		arr0.add("world");
		arr0.add("apple");
		arr0.add("apple");
		arr0.add("apple");
		for(int i = 0; i<arr0.size();i++){
			String cur = (String)arr0.get(i);
			for(int j = i+1; j<arr0.size();j++){
				String s = (String) arr0.get(j);
				if(s.equals(cur)){
					arr0.remove(s);
					j--;//删除元素之后，如果不做这一步就会漏掉对下一个元素的判断
				}				
			}

		}
		System.out.println(arr0);
	}
}

输出：
[hello, world, apple]

创建新数组的去重方案：

public static ArrayList deleteDuplic(ArrayList arr){
		ArrayList newArr = new ArrayList();
	for(int i = 0; i< arr.size();i++){
		String s = (String) arr.get(i);
		if(!newArr.contains(s)){
			newArr.add(s);			
		}
	}
	return newArr;
	}

对象数组去重（姓名相同且年龄相同就算重复）：

public static ArrayList DeleteDupStu(ArrayList<Student> arr){
		
		ArrayList<Student> newArr = new ArrayList<Student>();
		for(int i = 0; i < arr.size();i++){
			Student s = arr.get(i);
			String name = s.getName();
			int age = s.getAge();
			boolean flag = true;
			for(int j = 0; j <newArr.size();j++){
				Student s1 = newArr.get(j);
				String name1 =s1.getName();
				int age1 = s1.getAge();
				if(name == name1 && age == age1){
					flag = false;
				}
			}
			if(flag){
				newArr.add(s);
			}
			
		}
		return newArr;
	}

用LinkedList实现栈（继承的方式）

package testdemo;

import java.util.LinkedList;

public class StackBasedOnLink extends LinkedList {

	public StackBasedOnLink() {
		super();
	}
	
	public void push(Object obj){
		this.addFirst(obj);
	}
	
	public Object pop(){
		return this.removeFirst();
	}
	
}

package testdemo;

public class StackBasedOnLinkedDemo {
	public static void main(String[] args) {
		StackBasedOnLink sbo = new StackBasedOnLink();
		sbo.push("Hello");
		System.out.println(sbo);
		sbo.push("Kathy");
		System.out.println(sbo);
		sbo.push("Do");
		System.out.println(sbo);
		sbo.push("you");
		System.out.println(sbo);
		sbo.push("like");
		System.out.println(sbo);
		sbo.push("Java");
		System.out.println(sbo);
		System.out.println("==============================");
		while(!sbo.isEmpty()){
			//System.out.println(std);
			System.out.println(sbo.pop());
			
		}
		
	}
}
output:
[Hello]
[Kathy, Hello]
[Do, Kathy, Hello]
[you, Do, Kathy, Hello]
[like, you, Do, Kathy, Hello]
[Java, like, you, Do, Kathy, Hello]
==============================
Java
like
you
Do
Kathy
Hello

用LinkedList实现栈（非继承的方式）

package testdemo;

import java.util.LinkedList;

public class StackLinked{
	private LinkedList lkd;
	public StackLinked() {
		lkd = new LinkedList();
	}
	
	public void push(Object obj){
		lkd.addFirst(obj);
	}
	
	public Object pop(){		
		Object obj = lkd.getFirst();
		lkd.removeFirst();	
		return obj;
	}
	
	public boolean isEmpty(){
		return lkd.isEmpty();
	}

	@Override
	public String toString() {
		return  ""+lkd+"";
	}
		
}


package testdemo;

public class StackLinkedDemo {
	public static void main(String[] args) {
		StackLinked std = new StackLinked();
		std.push("Hello");
		System.out.println(std);
		std.push("Kathy");
		System.out.println(std);
		std.push("Do");
		System.out.println(std);
		std.push("you");
		System.out.println(std);
		std.push("like");
		System.out.println(std);
		std.push("Java");
		System.out.println(std);
		System.out.println("==============================");
		while(!std.isEmpty()){
			//System.out.println(std);
			System.out.println(std.pop());
			
		}
		
	}
}
output:
[Hello]
[Kathy, Hello]
[Do, Kathy, Hello]
[you, Do, Kathy, Hello]
[like, you, Do, Kathy, Hello]
[Java, like, you, Do, Kathy, Hello]
==============================
Java
like
you
Do
Kathy
Hello

3. 泛型类，泛型方法，泛型接口

泛型类，泛型方法

package testdemo;

class Calculate{
	public void show(String s){
		System.out.println(s);
	}
	
	public void show(Integer s){
		System.out.println(s);
	}
	
	public void show(Boolean s){
		System.out.println(s);
	}
}

class Calculate1<T>{
	private T obj;

	public Calculate1(T obj) {
		super();
		this.obj = obj;
	}

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}
	
}

class Calculate2<T>{
	public void show(T t ){
		System.out.println(t);
	}
}

public class FanXinDemo {
	public static void main(String[] args) {
		//一般重载
		Calculate c = new Calculate();
		c.show("hello");
		c.show(100);
		c.show(true);
		System.out.println("============================================");
		//泛型类
		Calculate1<String> cs = new Calculate1<>("hello");
		System.out.println(cs.getObj());
		Calculate1<Integer> cs1 = new Calculate1<>(100);
		System.out.println(cs1.getObj());
		Calculate1<Boolean> cs2 = new Calculate1<>(true);
		System.out.println(cs2.getObj());
		System.out.println("============================================");
		//泛型方法
		Calculate2 ce = new Calculate2();
		ce.show("hello");
		ce.show(true);
		ce.show(100);
	}
}

泛型接口

package testdemo;

interface Cal<T> {
	void show(T t);
}

class Calculator implements Cal{
	@Override
	public void show(Object t) {
		System.out.println(t);		
	}	
}

public class FanXinInterface {
	public static void main(String[] args) {
		Cal<String> c= new Calculator();
		c.show("Hello");
		Cal<Boolean> c1= new Calculator();
		c1.show(true);
	}
}

4. 泛型通配符
<?>：任意类型，如果没有明确，那么就是object类型和任意JAVA类型（如果明确写，那么左右要一致，比如：Collection ca = new ArrayList();）
<? extends E>：向下限定E以及其子类
<? super E>：向上限定E以及其父类

package testdemo;

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

public class FanxinSymbols {
	public static void main(String[] args) {
		Collection<Animal> ca = new ArrayList<Animal>();
		Collection<?> c = new ArrayList<Animal>();
		Collection<?> c1 = new ArrayList<Cat>();
		Collection<?> c2 = new ArrayList<Dog>();
		
		Collection<? extends Animal> c3 = new ArrayList<Animal>();
		Collection<? extends Animal> c4 = new ArrayList<Cat>();
		Collection<? extends Animal> c5 = new ArrayList<Dog>();
		
		Collection<? super Animal> c6 = new ArrayList<Animal>();
		Collection<? super Animal> c7 = new ArrayList<Object>();
	}
}
class Animal{
	
}
class Cat extends Animal{
	
}
class Dog extends Animal{
	
}

5. 增强for循环

JDK5之后为了方便集合的遍历而出现的，可以方便的遍历集合和数组。底层是迭代器（因此要注意，涉及到集合修改时，不要使用集合修改）

格式：
for(元素类型 变量（元素）：数组或Collection集合）{
}

6. 静态导入
可以直接导入到方法级别

格式：
import static 包名…类名.方法名

7. 可变参数

如果定义方法的时候不知道该定义多少个参数，那么就可以用可变参数来接收。

格式：

修饰符 返回值类型 方法名（数据类型… 变量名）{
}

注：
1）这里的变量其实是一个数组
2）如果有一个方法有可变参数，并且有多个可变参数，那么可变参数肯定是最后一个。
案例：
键盘录入多个数据，以0结束，要求在控制台输出这个数据中的最大值。

public class ChangableParaDemo {
	public static void main(String[] args) {
		findMax(2,3,6,7,10);
	}
	
	public static void findMax(int...is ){
		int sum = 0;
		for(int x: is){
			sum += x;
		}
		System.out.println(sum);
	}
}

package practicedemo;

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

public class FindMax {
	public static void main(String[] args) {
		//键盘录入多个数据，以0结束，要求在控制台输出这个数据中的最大值。
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数字，退出请输入0");
		ArrayList<Integer> c = new ArrayList<Integer>();
		int a = sc.nextInt();
		do{
			c.add(a);
			a = sc.nextInt();
		}while(a!=0);
		
		FindMax(c);
	}
	
	
	public static void FindMax(ArrayList<Integer> c){
		if(c.size()!=0){
			Integer max = c.get(0);
			for(int i = 1; i <c.size();i++){				
				Integer cur = c.get(i);
				if(cur>max){
					max =cur;					
				}
			}
			System.out.println(c);
			System.out.println(max);
		}
		
	}
}

注：两个Integer比较时，实际比较的是xx.intValue()
用反编译软件可以看出来。
以下是反编译的代码：

package practicedemo;

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Scanner;

public class FindMax
{

	public FindMax()
	{
	}

	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数字，退出请输入0");
		ArrayList c = new ArrayList();
		int a = sc.nextInt();
		do
		{
			c.add(Integer.valueOf(a));
			a = sc.nextInt();
		} while (a != 0);
		FindMax(c);
	}

	public static void FindMax(ArrayList c)
	{
		if (c.size() != 0)
		{
			Integer max = (Integer)c.get(0);
			for (int i = 1; i < c.size(); i++)
			{
				Integer cur = (Integer)c.get(i);
				if (cur.intValue() > max.intValue())
					max = cur;
			}

			System.out.println(c);
			System.out.println(max);
		}
	}
}

8. ArrayList的toString（）方法

toString（）方法存在于其继承的父类的父类AbstractCollection中。

public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {//for (;;)跟while（true）差不多
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);//如果e元素就是本类name就添加 "(this Collection)"如果不是就添加e元素
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
KathyLJQ
关注
专栏目录
黑马程序员-- java集合类--Vector/泛型
whf769的专栏
06-10 1319
  集合类--Vector/泛型   Java用集合类来容纳不同种类的数据，java.util包中提供的向量(Vector)类就是集合类的一种。       该类是Java语言为解决数组长度和元素类型不能改变而引入的集合类，用来表示线性数据结构。 构造方法     public Vector()：创建一个空向量对象     public Vector(int initialCapacity)：使用
Java基础----ArrayList、Vector、LinkedList、泛型(Generic)
qq_62520680的博客
12-06 359
1. ArrayList遍历 除了迭代器和普通for循环遍历外，JDK1.8新增的一个方法也能遍历集合： void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable，直到所有元素都被处理或操作抛出异常 1.1 ArrayList存储自定义对象并遍历 自定义一个Student类 package Demo1; ​ /** * @Author: King * @Description:人类的伟大是勇气的伟大，人类的赞歌是
Java--集合框架--ArrayList、 Vector、 LinkedList、 泛型(Generic) 、 可变参数 、增强for循环
weixin_43216479的博客
02-15 234
ArrayList Vector LinkedList 泛型(Generic) 可变参数 增强for循环 集合框架(ArrayList存储字符串并遍历) ​ JDK1.8新增的一个方法也能遍历集合 ​ void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 集合框架(Vec...
Java学习日志Day20_List列表迭代器_ArrayList/Vector/LinkedList对比_增强for循环_Set集合
igfff的博客
05-24 157
一、List列表迭代器 List集合的获取功能(List集合的专有遍历方式): ListIterator listIterator() :获取列表迭代器 ListIterator 正向遍历 boolean hasNext():判断是否有下一个可以迭代的元素 E next():获取下一个元素 逆向遍历 boolean hasPrevious():判断是否有上一个可以迭代的元素 E previous():获取上一个
16.集合框架(ArrayList,Vector,LinkedList,泛型(Generic),可变参数,增强for循环)
weixin_62520626的博客
11-21 541
1.ArrayList存储字符串并遍历 JDK1.8新增的一个方法也能遍历集合 void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 1.案例演示: ArrayList存储字符串并遍历 迭代器 普通for public class MyTest { public static void main(String[] args) { ...
泛型类 泛型方法 Vector LinkedList
weixin_52946124的博客
04-04 236
1、请简述泛型是什么?有什么用?在哪里用？ 2、请把今天讲解的方法，在API中查找到，并用自己的话进行描述 答案： ​ Vector ​ public void addElement(E obj) Vector特有的的添加方法 ​ public E elementAt(int index) 返回对应索引的元素 public boolean removeElement(Object obj) 根据集合中的元素删除元素 public void removeElementAt(
Java软件开发实战 Java基础与案例开发详解 11-1 Java集合框架和泛型机制 共6页.pdf
最新发布
07-07
`Collection`接口是Java集合框架的根接口，所有具体的集合类都是它的实现类。`Collection`接口的主要方法有： - `add(E e)`：如果此集合尚未包含指定元素，则将其添加到此集合中。 - `remove(Object o)`：从此集合...
JAVA＜集合框架＞②--ArrayList、Vector、LinkedList
weixin_42875313的博客
04-06 159
1.集合的概念 2.Collection接口 3.List接口与实现类 4.泛型和工具类 5.Set接口与实现类 6.Map接口与实现类 一.List实现类： -ArrayList【重点】： 1.数组结构实现，查询快、增删慢； 2.JDK1.2版本，运行效率快、线程不安全。 -Vector： 1.数组结构实现，查询快、增删慢； 2.JDK1.0版本，运行效率慢、线程安全。 -LinkedList： 1.链表结构实现，增删快，查询慢。 1.ArrayList的使用： import org...
集合，ArrayList,LinkedList,Vector,泛型概述，增强for循环
qq_42667840的博客
05-14 131
集合和数组的特点： 1.共同点：都作为容器，存储元素。 2.不同点：数组：数组只能存同一种类型的数据，可以存储基本类型和引用类型，创建完成之后长度固定，不可以临时增加或者删除集合：只能存储引用类型的数据，集合的长度是可以变的。一个集合可以存储各种类型的数据。 ...
常用的被泛型化的集合类
qq_41978199的博客
06-15 290
package T泛型;import java.util.ArrayList;import java.util.HashMap;import java.util.Map;import java.util.Vector;/* * 常用的被泛型化的集合类 * 集合类                                           泛型定义 * ArrayList        Ar...
不要用for循环去遍历LinkedList
meser88的博客
10-30 277
转自：https://www.cnblogs.com/zhilu-doc/p/5292818.html   ArrayList与LinkedList的普通for循环遍历 对于大部分Java程序员朋友们来说，可能平时使用得最多的List就是ArrayList，对于ArrayList的遍历，一般用如下写法：   public static void main(String[] args...
java增强for循环_Java中增强for循环的实现原理和坑详解
weixin_39616416的博客
02-12 1740
前言引入增强for循环的原因：在JDK5以前的版本中，遍历数组或集合中的元素，需要先获得数组的长度或集合的迭代器，比较麻烦。JDK5中定义了一种新的语法----增强for循环，以简化此类操作。增强for循环只能用在数组或实现Iterable接口的集合上。语法格式：for(变量类型 变量：需迭代的数组或集合)｛｝在JAVA中，遍历集合和数组一般有以下三种形式：for (int i = 0; i &l...
java不用循环输出集合_不要用for循环去遍历LinkedList
weixin_39780260的博客
02-17 1081
ArrayList与LinkedList的普通for循环遍历对于大部分Java程序员朋友们来说，可能平时使用得最多的List就是ArrayList，对于ArrayList的遍历，一般用如下写法：public static voidmain(String[] args){List arrayList =new ArrayList();for (int i = 0; i < 100; i++)a...
java基础（13）（collection集合，迭代器的使用，增强for循环，list集合，arrayList和linkedList集合的使用）
qq_41934990的博客
04-26 366
集合 集合是java中提供的一种容器，可以用来存储多个数据,并且可以存储任意类型的数据 集合与数组的区别 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。 集合的体系 Collection集合 Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collectio
JAVA vector的遍历_【遍历集合】Java遍历List,Map,Vector，Set的几种方法
weixin_28949355的博客
02-16 497
1、遍历list@Testpublic void testList() {List list = new ArrayList();list.add(1);list.add(2);System.out.println("-------------------list------------------");System.out.println("-------增强for循环list----");fo...
增强for循环的使用（数组和集合遍历尤为简单）
m0_52646273的博客
05-11 1606
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。 格式： for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码 } 它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。 package day02collection; import java.util.A
java 中加强for循环_java中的增强FOR循环
weixin_39610229的博客
02-16 329
JDK1.5中增加了增强的for循环。缺点：对于数组，不能方便的访问下标值；对于集合，与使用Interator相比，不能方便的删除集合中的内容(在内部也是调用Interator).除了简单遍历并读取其中的内容外，不建议使用增强的for循环。一、遍历数组语法为:for (Type value : array) {expression value;}//以前我们这样写：void someFunctio...
遍历集合的两种方式：迭代器和增强型for循环
SimonChen
09-07 564
package drchen.java.demo02; /*遍历集合有两种方式： 1.迭代器（步骤如下） step1：构建集合，并往里面添加元素 step2:通过集合对象获取迭代器对象 step3：使用while和hasNext()方法来判断迭代器对象里是否还有元素 step4：使用next()来获取元素 2.增强for循环 格式： for(数据类型 变量名 : 容器对象){ //循环体语句 } 这里的容器对象不仅仅指的
Java集合类详解：ArrayList, Vector, LinkedList比较
"Java集合类用法" Java集合类是Java编程中不可或缺的一部分，它们用于存储和操作对象。集合框架是Java API的核心组件，提供了多种数据结构的实现，使得开发者能够更高效地处理对象集合。以下是对Java集合类的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值