Java基础之List的子类（ListArray，LinkedList，Vector）

最新推荐文章于 2023-11-28 14:39:28 发布
最新推荐文章于 2023-11-28 14:39:28 发布
阅读量405 收藏 3
点赞数
分类专栏： java 文章标签： Java基础之List的子类 java基础之ArrayList Java基础之Vector Java基础之LinkedList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Future_LL/article/details/80231352
版权

 List 集合：

        List 的子类：                
                 ArrayList：
         1> 底层数据结构式数组结构，查询块，增删慢；
         2> 从内存角度考虑：线程不安全的，不同步的，执行效率高；
         3> 多线程：synchronized（同步的意思 ==> 解决线程安全问题）；
        sychronized(锁对象){ //同步代码 
        共享数据；
        }
         4> 解决线程安全问题，通过同步可以解决，但是效；率低了；
         LinkedList：
         1> 底层数据结构式链表结构，查询慢，增删块；
         2> 从内存角度考虑：线程不安全，不同步，执行效率高；
         Vector：
         1> 这是一个线程安全的类，底层数据结构是数组：查询快，增删慢；

         2> 线程安全的，同步，执行效率低；

ArrayList：是List接口中常用的一个子实现类；

        遍历功能：
                 1> 一个是Collection的iterator( )；

2> size()和get(int index)普通for循环；

        举例：

public class ArrayListDemo {

	public static void main(String[] args) {
		
		//创建集合对象
		ArrayList list = new ArrayList() ;
		
		//添加元素
		list.add("hello") ;
		list.add("world") ;
		list.add("java") ;
		
		
		//遍历
		//方式1:获取迭代器
		Iterator it = list.iterator() ;
		while(it.hasNext()) {
			String s = (String)it.next() ;
			System.out.println(s);
		}
		
		System.out.println("-----------------------");
		
                //方式2:使用size()和get(int index)加上for循环遍历
		for(int x = 0 ; x < list.size() ; x ++) {
			String s = (String) list.get(x) ;
			System.out.println(s);
		}
		
	}
}
        ArrayList集合存储自定义对象并遍历：
                    举例： 
import java.util.ArrayList;
import java.util.Iterator;

/**
 * ArrayList集合存储自定义对象并遍历
 */
class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	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;
	}
}
public class ArrayListDemo2 {
	
	public static void main(String[] args) {
		
		//创建集合对象
		ArrayList  array = new ArrayList();
		
		//创建学生对象
		Student s1 = new Student("鲁智深", 30) ;
		Student s2 = new Student("武松", 40) ;
		Student s3 = new Student("宋江", 50) ;
		Student s4 = new Student("杨志", 25) ;
		
		//添加元素
		array.add(s1) ;
		array.add(s2) ;
		array.add(s3) ;
		array.add(s4) ;
		
		//迭代器方式
		Iterator it = array.iterator() ;
		while(it.hasNext()) {
			Student s = (Student)it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		System.out.println("--------------------");
		//集合遍历
		for(int x = 0 ; x <array.size() ; x ++) {
			Student s = (Student)array.get(x) ;
			System.out.println(s.getName()+"----"+s.getAge());
		}
	}
}
        综合练习： 
package org.westos_05;

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

/**
 *需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!
 *
 *思路:
 *		1)创建一个旧集合,添加重复元素
 *		2)创建一个新集合
 *		3)遍历旧集合中的元素获取到每一个元素
 *			在旧集合中判断新集合中是否包含旧集合中的元素
 *				包含,不搭理
 *				不包含,添加到新集合中
 *
 *		4)遍历新集合
 */
public class ArrayListTest {
	
	public static void main(String[] args) {
		
		//创建一个集合
		ArrayList list = new ArrayList() ;
		
		//添加元素
		list.add("hello") ;
		list.add("world") ;
		list.add("java") ;
		list.add("javaee") ;
		list.add("hello") ;
		list.add("world") ;
		list.add("hello") ;
		list.add("javaee") ;
		list.add("android") ;
		list.add("python") ;
		list.add("php") ;
		list.add("php") ;
		
		//创建一个新的集合
		ArrayList newList = new ArrayList() ;
		
		//遍历旧集合
		Iterator it = list.iterator() ;
		while(it.hasNext()) {
			String s = (String) it.next() ;
			
			//判断新集合中是否包含旧集合中的元素
			if(!newList.contains(s)) {
				newList.add(s) ;
			}
		}
		
		//遍历新集合
		Iterator it2 = newList.iterator() ;
		while(it2.hasNext()) {
			String s = (String) it2.next() ;
			System.out.println(s);
		}
	}
}
        注意：
                1> 如果上述例题允许创建一个新的集合，怎么办？ 
//使用双层for循环来求解:
//引入选择排序，两个两个比较，要是相等，那么久删除后边的元素，继续循环判断，知道程序结束
for(int x = 0 ; x < array.size()-1 ; x ++) {
	for(int y = x +1 ; y < array.size() ; y ++) {
		//判断,前面的索引对应的元素和后面索引对应的元素进行比较,如果相等就干掉后面重复的
		if(array.get(x).equals(array.get(y))) {
			array.remove(y) ;
			y-- ;
		}
	}
}
                2> 使用集合ArrayList存储自定义对象(Student)，去除重复的对象：
                        问题：这里如果在Student类中没有重写equals方法，那么程序执行错误；
                        原因：contains的底层需要用equals，equals默认比较的是地址值，所以想要内容相等就需要 重写equals方法； 
//创建一个新集合
ArrayList newArray = new ArrayList() ;
		
//遍历旧集合
Iterator it = array.iterator() ;
while(it.hasNext()) {
	Student s = (Student)it.next() ;
			
	//判断,新集合中是否包含
	if(!newArray.contains(s)) {   //contains底层依赖于equals方法,想要比较内容需要重写equals方法;
		newArray.add(s) ;
	}
}
		
//遍历新集合
Iterator it2 = newArray.iterator() ;
while(it2.hasNext()) {
	Student s= (Student)it2.next();
	System.out.println(s.getName()+"---"+s.getAge());
}

Vector集合：

        特有功能：
                public void addElement(Object obj)  --->相当于：add(Object obj)；
                public Enumeration elements():返回此向量的枚举--->相当于：public Iterator iterator()；
                boolean hasMoreElements()  --->相当于：boolean hasNext()；

                Object nextElement() --->相当于：Object next() ;

        举例：

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

public class VectorDemo {
	
	public static void main(String[] args) {
		
		//创建集合对象
		Vector v = new Vector() ;
		
		//添加元素
		v.addElement("hello"); 
		v.addElement("world");
		v.addElement("java");
		
		//遍历
		//获取Enumeration :向量的枚举
		Enumeration en = v.elements() ;
		while(en.hasMoreElements()) {
			String s = (String)en.nextElement() ;
			System.out.println(s);
		}
	}
}


LinkedList集合：

        特有功能：
                 添加功能：
        addFirst(Object e)：将指定的元素插入到列表的开头；
        addLast(object e)：将指定的元素添加到列表末尾；
         获取功能：
        getFirst()：获取列表第一个元素；
        getLast()：获取列表第二个元素；
         删除功能：
        public Object removeFirst()：移除并返回此列表的第一个元素；
                        public Object removeLast()：移除并返回此列表的最后一个元素；

        举例：

import java.util.LinkedList;

public class LinkedListDemo {
	
	public static void main(String[] args) {
		
		//创建LinkedList集合对象
		LinkedList link = new LinkedList() ;
		
		//添加元素
		link.add("hello"); 
		link.add("world"); 
		link.add("java"); 
		System.out.println("link:"+link);
		
		//addFirst(Object e):将指定的元素插入到列表的开头
		link.addFirst("android");
		System.out.println("link:"+link);
		
		//addLast(object e):将指定的元素添加到列表末尾
		link.addLast("mysql");
		System.out.println("link:"+link);
		
		//getFirst():获取列表第一个元素
		System.out.println(link.getFirst());
		System.out.println(link.getLast());
		
		//public Object removeFirst()移除并返回此列表的第一个元素。 
		System.out.println("removeFirst():"+link.removeFirst());
		System.out.println("link:"+link);
		
		//public Object removeLast()
		System.out.println("removeLast():"+link.removeLast());
		System.out.println("link:"+link);
	}
}

        使用LinkedList模拟一个栈：(先进后出)；

                举例：

package org.westos_04;

import java.util.Iterator;
import java.util.LinkedList;

/**
 * 需求:
 * 		模拟栈结构的特点,先进后出
 * 
 * 理解:需要自定义一个类,在这个类中使用LinkedList集合的特有功能进行操作
 * 		
 *
 */

public class LinkedListDemo {
	
	public static void main(String[] args) {
		
		//创建linkedList集合对象
		LinkedList link = new LinkedList() ;
		
		//添加元素
		//符合栈结构的特点:先进后出
		link.addFirst("hello");
		link.addFirst("world");
		link.addFirst("java");
		
		//使用迭代器遍历
		Iterator it = link.iterator() ;
		while(it.hasNext()) {
			String s = (String)it.next();
			System.out.println("s:"+s);
		}
		
	}
}

Future_LL
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java 集合框架：Vector、Stack 的介绍、使用、原理与源码解析
最新发布
栗筝i的博客
06-20 3524
Java 集合框架（Java Collections Framework）是 Java 标准库中的一个核心组件，它提供了一套用于处理数据集合的接口和类。作为其中的重要成员，Vector 和 Stack 在特定场景中扮演着关键角色。Vector 是一种同步的动态数组，实现了 List 接口，适用于需要线程安全的场景；而 Stack 是 Vector 的子类，提供了后进先出（LIFO）的数据结构操作。本文将对 Vector 和 Stack 进行全面的介绍，探讨它们的使用方法、工作原理以及源码实现，以帮助开发者深
Java中List集合的子类
feizuiku0116的博客
12-13 1311
一、常用子类 List集合是一个接口，它的常用子类有两个，分别是ArrayList，LinkedList ArrayList集合的特点：底层数据结构是数组，查询和修改快，增删慢 LinkedList集合的特点：底层数据结构是链表，查询和修改慢，增删慢 相同点：都是有序的，而且可以存储重复元素 /** * 定义学生类，属性为姓名和年龄 * 创建ArrayList集合，用来存储学生信息 * 往集合中添加3个学生对象 * 通过三种方式，遍历上述的集合 */ public class Student
java list 子类_JAVA-基础（List及其子类）
weixin_30582757的博客
02-12 457
JAVA-基础(List及其子类)1.什么是List？java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。2.list集合的特点？它是一个元素存取有序的集合。简单来说就是队列方式存取。它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。集合中可以有重复的元素，通过元素的e...
Java中List集合的三个子类ArrayList、Vector、LinkedList
liuchonghua的博客
05-09 878
区别List集合和Set集合的区别 ArrayListVectorLinkedList底层结构数组结构数组结构链表结构特点查询快，增删慢查询块,增删慢查询慢，增删块安全性不安全，不同步，效率高安全的，同步的，效率低不安全，不同步，效率高...
Java中list集合子类
qq_53009248的博客
02-24 469
一，常用子类 List集合常用子类Arraylist,linkedlist Arraylist:底层数据结构是数组，查询快，增删慢 LinkedList:底层数据结构是链表。查询慢，增删快 二，LinkedList集合的特有功能 方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定元素追加到列表的末尾 public E getFirst() 返回列表中的第一个元素 public
java list子类_List集合的子类ArrayList、LinkedList、Vector
weixin_31967551的博客
02-13 98
List：有序，有索引，可重复。|--ArrayList:底层数据结构是 数组结构.是线程不同步的(不安全的).查询速度很快，但是增删较慢。构造一个初始容量为 10 的空列表，当放满了10个元素后，以50%的长度加长集合容器的长度。List 接口的大小可变数组的实现,即：可以直接指定容量大小|--LinkedList:底层数据结构是 链表结构。对元素的增删速度很快。但是查询速度很慢。线程是不同步的...
67从零开始学Java之List集合有哪些特性？
一一哥
11-28 1102
在上一篇文章中，壹哥给大家介绍了Java里的集合，我们了解了集合的由来、特点，以及一些接口API等，但这些内容都偏重于理论。那么从今天这篇文章开始，我们会从实战的角度来进行List集合的学习。可以说，List集合是开发时用的最多的一种集合，尤其是ArrayList更是被经常使用。所以对今天的内容，壹哥希望大家要好好阅读和练习。前戏已做完，精彩即开始全文大约【5800】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！
【Java Collection】常见 List 子类剖析（三）
Sword52888的博客
10-13 285
二、 RandomAccess 接口子类 三、 AbstractSequentialList 抽象类子类
Java基础之List实现篇
#include<?>
03-26 1285
[参考原文]http://www.cnblogs.com/skywang12345/p/3308556.htmlArrayListArrayList简介ArrayList 是一个 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。ArrayLis
java list 子类_Java集合(一) -- List常用子类实现-搜云库
weixin_42554162的博客
02-12 175
一：摘要概述ArrayList继承结构讲解ArrayList实现数据结构与初始化时间ArrayList数组扩容策略ArrayList插入操作ArrayList遍历操作LinkedList数据结构LinkedList继承结构LinkedList遍历操作LinkedList结构变更效率Vector线程安全保证二：ArrayList继承结构ArrayList作为集合中常用的类,归属于Collection...
Java基础----容器List
bluzelee2011的专栏
12-27 538
集合和数组的区别? A:长度区别 数组固定 集合可变 B:内容区别 数组可以是基本类型，也可以是引用类型 集合只能是引用类型 C:元素内容 数组只能存储同一种类型 集合可以存储不同类型(其实集合一般存储的也是同一种类型) import java.util.ArrayList; import java.util.Iterator; import java.util.List; i
javaAPI_集合基础_List的三个子类基本使用
ahow81212的博客
12-31 110
List的三个子类基本使用 ArrayList 1.ArrayList类概述 ArrayList的底层数据结构是数组，查询快，增删慢。属于线程不安全，但是效率高。 2.ArrayList使用案例[使用ArrayList存储对象并遍历] public static void main(String[] args) { ArrayList lt = new ArrayList...
Java类集之List及其常用子类
shangshanzixu的博客
07-09 381
List接口 List接口是Collection接口的子接口，与Set不同的是List中的元素是有序且允许重复的。所以List接口提供了根据索引获取元素。 ArrayList ArrayList是基于对象数组实现的，ArrayList不是线程同步的，它允许重复元素，允许加入null值。默认扩容长度为原长度的1.5倍。 下面我们从ArrayList的构造方法说起 第一个无参的构造和传入collection的构造都是Collection接口中指定的，在Collection官方文档中可以看到。 译文：所有通
java 中 List集合子类特点
weixin_59796310的博客
01-01 1510
java 中 List集合子类特点
JAVA:List集合子类特点
加菲的博客
08-05 247
List集合子类特点 List集合子类：ArrayList , LinkedList
JAVA-基础（List及其子类）
weixin_34226706的博客
06-15 356
JAVA-基础（List及其子类） 1.什么是List？ java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。 2.list集合的特点？ 它是一个元素存取有序的集合。简单来说就是队列方式存取。 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。 集合中可以有重复的元素，...
Java中List接口、各子类之间的介绍及区别
梦里蓝天
09-10 776
List接口介绍 List是一种有序的列表（也称为序列 ），用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问列表中的元素，并搜索列表中的元素。 与集合不同，列表允许重复的元素，并且通常允许多个空元素。 该List接口放置额外的约定，超过在Collection指定接口上的iterator，add，remove，equals和hashCode方法合同。 其他继承方法的声明也包括在这里以方便。 常见的List接口实现类 1. ArrayList 可调整大小的List接口的实现
List集合与List的子类
qq_39368007的博客
01-29 350
掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？ Collection中的常用几个子类（java.util.List集合、java.util.Set集合） List接口介绍 List接口特点： 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值