java的LinkedList详解
2016-11-30 21:48
387 查看
集合 的体系:
------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类,具备的特点: 有序,可重复。
-------------------| ArrayList ArrayList 底层是维护了一个Object数组实现的。 特点: 查询速度快,增删慢。
-------------------| LinkedList LinkedList 底层是使用了链表数据结构实现的, 特点: 查询速度慢,增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的,实现与ArrayList是一样的,但是Vector是线程安全的,操作效率低。
----------------| Set 如果是实现了Set接口的集合类,具备的特点: 无序,不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的,特点: 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性,那么就按照元素自然顺序的特性进行排序存储。
Linkedlist特有的方法:
1:方法介绍
addFirst(E e)
addLast(E e)
getFirst()
getLast()
removeFirst()
removeLast()
2:数据结构
1:栈 (1.6) : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2:队列(双端队列1.5): 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()
3:返回逆序的迭代器对象
descendingIterator() 返回逆序的迭代器对象
import java.util.Iterator;
import java.util.LinkedList;
public class Demo8 {
public static void main(String[] args) {
LinkedList list= new LinkedList();
list.add("张三");
list.add("李四");
list.add("王五");
/*
list.addFirst("狗娃"); //把元素添加到集合的首位置上。
list.addLast("狗剩"); //把元素添加到集合的末尾处。
System.out.println("获取集合中首位置的元素:"+list.getFirst());
System.out.println("获取集合中末尾的元素:"+ list.getLast());
System.out.println("删除集合中的首位置元素并返回:"+ list.removeFirst());
System.out.println("删除集合中的末尾素并返回:"+ list.removeLast());
list.push("狗娃"); //将该元素插入此集合的开头处。
System.out.println("删除集合的首元素:"+list.pop()); // 移除并返回集合中的第一个元素
list.offer("狗剩");
System.out.println("删除集合的首元素: "+list.poll());
System.out.println("集合中的元素:"+ list);
*/
Iterator it = list.descendingIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果:
王五
李四
张三
1:栈 (1.6) : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2:队列(双端队列1.5): 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()
机试题目: 使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式。
使用LinkedList模拟堆栈的数据结构存储方式
import java.util.LinkedList;
class StackList{
LinkedList list;
public StackList(){
list = new LinkedList();
}
//进栈
public void add(Object o){
list.push(o);
}
//弹栈 : 把元素删除并返回。
public Object pop(){
return list.pop();
}
//获取元素个数
public int size(){
return list.size();
}
}
//使用LinkedList模拟队列的存储方式
class TeamList{
LinkedList list;
public TeamList(){
list = new LinkedList();
}
public void add(Object o){
list.offer(o);
}
public Object remove(){
return list.poll();
}
//获取元素个数
public int size(){
return list.size();
}
}
public class Demo9 {
public static void main(String[] args) {
TeamList list= new TeamList();
list.add("李嘉诚");
list.add("马云");
list.add("王健林");
int size = list.size();
for(int i = 0 ; i<size ; i++){
System.out.println(list.remove());
}
}
}
运行结果:
李嘉诚
马云
王健林
import java.util.LinkedList;
class Person{
String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{ 名字:"+ this.name+" 年龄:"+ this.age+"}";
}
}
public class Demo3 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(new Person("狗娃", 7));
list.add(new Person("狗剩", 17));
list.add(new Person("铁蛋", 3));
list.add(new Person("美美", 30));
//编写一个函数根据人的年龄及逆行排序存储。
for(int i= 0 ; i<list.size() -1 ; i++){
for(int j = i+1 ; j<list.size() ; j++){
//符合条件交换位置
Person p1 = (Person) list.get(i);
Person p2 = (Person) list.get(j);
if(p1.age>p2.age){
//交换位置
list.set(i, p2);
list.set(j, p1);
}
}
}
System.out.println(list);
}
}
运行结果:
[{ 名字:铁蛋 年龄:3}, { 名字:狗娃 年龄:7}, { 名字:狗剩 年龄:17}, { 名字:美美 年龄:30}]
需求: 使用LinkedList存储一副扑克牌,然后实现洗牌功能。
import java.util.LinkedList;
import java.util.Random;
/*
需求: 使用LinkedList存储一副扑克牌,然后实现洗牌功能。
*/
//扑克类
class Poker{
String color; //花色
String num; //点数
public Poker(String color, String num) {
super();
this.color = color;
this.num = num;
}
@Override
public String toString() {
return "{"+color+num+"}";
}
}
public class Demo2 {
public static void main(String[] args) {
LinkedList pokers = createPoker();
shufflePoker(pokers);
showPoker(pokers);
}
//洗牌的功能
public static void shufflePoker(LinkedList pokers){
//创建随机数对象
Random random = new Random();
for(int i = 0 ; i <100; i++){
//随机产生两个索引值
int index1 = random.nextInt(pokers.size());
int index2 = random.nextInt(pokers.size());
//根据索引值取出两张牌,然后交换两张牌的顺序
Poker poker1 = (Poker) pokers.get(index1);
Poker poker2 = (Poker) pokers.get(index2);
pokers.set(index1, poker2);
pokers.set(index2, poker1);
}
}
//显示扑克牌
public static void showPoker(LinkedList pokers){
for(int i = 0 ; i<pokers.size() ; i++){
System.out.print(pokers.get(i));
//换行
if(i%10==9){
System.out.println();
}
}
}
//生成扑克牌的方法
public static LinkedList createPoker(){
//该集合用于存储扑克对象。
LinkedList list = new LinkedList();
//定义数组存储所有的花色与点数
String[] colors = {"黑桃","红桃","梅花","方块"};
String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for(int i = 0 ; i < nums.length ; i++){
for(int j = 0 ; j<colors.length ; j++){
list.add(new Poker(colors[j], nums[i]));
}
}
return list;
}
}
运行结果:
{黑桃Q}{红桃K}{方块3}{红桃10}{梅花A}{梅花6}{红桃4}{红桃8}{黑桃10}{梅花9}
{黑桃2}{方块J}{红桃5}{梅花2}{梅花7}{黑桃A}{黑桃K}{梅花K}{红桃A}{黑桃6}
{方块2}{黑桃4}{红桃2}{梅花5}{梅花J}{方块4}{方块K}{红桃6}{黑桃5}{黑桃3}
{方块9}{红桃7}{红桃J}{红桃9}{红桃3}{红桃Q}{梅花4}{黑桃J}{方块A}{方块5}
{方块6}{黑桃7}{方块8}{梅花8}{方块10}{方块Q}{梅花Q}{梅花10}{梅花3}{黑桃8}
{黑桃9}{方块7}
------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类,具备的特点: 有序,可重复。
-------------------| ArrayList ArrayList 底层是维护了一个Object数组实现的。 特点: 查询速度快,增删慢。
-------------------| LinkedList LinkedList 底层是使用了链表数据结构实现的, 特点: 查询速度慢,增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的,实现与ArrayList是一样的,但是Vector是线程安全的,操作效率低。
----------------| Set 如果是实现了Set接口的集合类,具备的特点: 无序,不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的,特点: 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性,那么就按照元素自然顺序的特性进行排序存储。
Linkedlist特有的方法:
1:方法介绍
addFirst(E e)
addLast(E e)
getFirst()
getLast()
removeFirst()
removeLast()
2:数据结构
1:栈 (1.6) : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2:队列(双端队列1.5): 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()
3:返回逆序的迭代器对象
descendingIterator() 返回逆序的迭代器对象
import java.util.Iterator;
import java.util.LinkedList;
public class Demo8 {
public static void main(String[] args) {
LinkedList list= new LinkedList();
list.add("张三");
list.add("李四");
list.add("王五");
/*
list.addFirst("狗娃"); //把元素添加到集合的首位置上。
list.addLast("狗剩"); //把元素添加到集合的末尾处。
System.out.println("获取集合中首位置的元素:"+list.getFirst());
System.out.println("获取集合中末尾的元素:"+ list.getLast());
System.out.println("删除集合中的首位置元素并返回:"+ list.removeFirst());
System.out.println("删除集合中的末尾素并返回:"+ list.removeLast());
list.push("狗娃"); //将该元素插入此集合的开头处。
System.out.println("删除集合的首元素:"+list.pop()); // 移除并返回集合中的第一个元素
list.offer("狗剩");
System.out.println("删除集合的首元素: "+list.poll());
System.out.println("集合中的元素:"+ list);
*/
Iterator it = list.descendingIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果:
王五
李四
张三
1:栈 (1.6) : 主要是用于实现堆栈数据结构的存储方式。
先进后出
push()
pop()
2:队列(双端队列1.5): 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
先进先出
offer()
poll()
机试题目: 使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式。
使用LinkedList模拟堆栈的数据结构存储方式
import java.util.LinkedList;
class StackList{
LinkedList list;
public StackList(){
list = new LinkedList();
}
//进栈
public void add(Object o){
list.push(o);
}
//弹栈 : 把元素删除并返回。
public Object pop(){
return list.pop();
}
//获取元素个数
public int size(){
return list.size();
}
}
//使用LinkedList模拟队列的存储方式
class TeamList{
LinkedList list;
public TeamList(){
list = new LinkedList();
}
public void add(Object o){
list.offer(o);
}
public Object remove(){
return list.poll();
}
//获取元素个数
public int size(){
return list.size();
}
}
public class Demo9 {
public static void main(String[] args) {
TeamList list= new TeamList();
list.add("李嘉诚");
list.add("马云");
list.add("王健林");
int size = list.size();
for(int i = 0 ; i<size ; i++){
System.out.println(list.remove());
}
}
}
运行结果:
李嘉诚
马云
王健林
import java.util.LinkedList;
class Person{
String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{ 名字:"+ this.name+" 年龄:"+ this.age+"}";
}
}
public class Demo3 {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(new Person("狗娃", 7));
list.add(new Person("狗剩", 17));
list.add(new Person("铁蛋", 3));
list.add(new Person("美美", 30));
//编写一个函数根据人的年龄及逆行排序存储。
for(int i= 0 ; i<list.size() -1 ; i++){
for(int j = i+1 ; j<list.size() ; j++){
//符合条件交换位置
Person p1 = (Person) list.get(i);
Person p2 = (Person) list.get(j);
if(p1.age>p2.age){
//交换位置
list.set(i, p2);
list.set(j, p1);
}
}
}
System.out.println(list);
}
}
运行结果:
[{ 名字:铁蛋 年龄:3}, { 名字:狗娃 年龄:7}, { 名字:狗剩 年龄:17}, { 名字:美美 年龄:30}]
需求: 使用LinkedList存储一副扑克牌,然后实现洗牌功能。
import java.util.LinkedList;
import java.util.Random;
/*
需求: 使用LinkedList存储一副扑克牌,然后实现洗牌功能。
*/
//扑克类
class Poker{
String color; //花色
String num; //点数
public Poker(String color, String num) {
super();
this.color = color;
this.num = num;
}
@Override
public String toString() {
return "{"+color+num+"}";
}
}
public class Demo2 {
public static void main(String[] args) {
LinkedList pokers = createPoker();
shufflePoker(pokers);
showPoker(pokers);
}
//洗牌的功能
public static void shufflePoker(LinkedList pokers){
//创建随机数对象
Random random = new Random();
for(int i = 0 ; i <100; i++){
//随机产生两个索引值
int index1 = random.nextInt(pokers.size());
int index2 = random.nextInt(pokers.size());
//根据索引值取出两张牌,然后交换两张牌的顺序
Poker poker1 = (Poker) pokers.get(index1);
Poker poker2 = (Poker) pokers.get(index2);
pokers.set(index1, poker2);
pokers.set(index2, poker1);
}
}
//显示扑克牌
public static void showPoker(LinkedList pokers){
for(int i = 0 ; i<pokers.size() ; i++){
System.out.print(pokers.get(i));
//换行
if(i%10==9){
System.out.println();
}
}
}
//生成扑克牌的方法
public static LinkedList createPoker(){
//该集合用于存储扑克对象。
LinkedList list = new LinkedList();
//定义数组存储所有的花色与点数
String[] colors = {"黑桃","红桃","梅花","方块"};
String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for(int i = 0 ; i < nums.length ; i++){
for(int j = 0 ; j<colors.length ; j++){
list.add(new Poker(colors[j], nums[i]));
}
}
return list;
}
}
运行结果:
{黑桃Q}{红桃K}{方块3}{红桃10}{梅花A}{梅花6}{红桃4}{红桃8}{黑桃10}{梅花9}
{黑桃2}{方块J}{红桃5}{梅花2}{梅花7}{黑桃A}{黑桃K}{梅花K}{红桃A}{黑桃6}
{方块2}{黑桃4}{红桃2}{梅花5}{梅花J}{方块4}{方块K}{红桃6}{黑桃5}{黑桃3}
{方块9}{红桃7}{红桃J}{红桃9}{红桃3}{红桃Q}{梅花4}{黑桃J}{方块A}{方块5}
{方块6}{黑桃7}{方块8}{梅花8}{方块10}{方块Q}{梅花Q}{梅花10}{梅花3}{黑桃8}
{黑桃9}{方块7}
相关文章推荐
- Java中的ArrayList 、List、LinkedList、Collection关系详解
- Java的LinkedList详解,看源码之后的总结
- java容器类详解--LinkedList
- Java集合:LinkedList详解
- java集合LinkedList的底层实现源码详解
- 用java源代码学数据结构<四>: LinkedList 详解
- java中的ArrayList 、List、LinkedList、Collection关系详解
- Java中LinkedList详解和使用示例_动力节点Java学院整理
- Java集合之ArrayList和LinkedList的实现原理以及Iterator详解
- Java 集合之List、ArrayList、LinkedList以及Vector详解
- JAVA详解双向循环链表(参照java.util.LinkedList)
- Java中 ArrayList、Vector和LinkedList 的使用和详解(转)
- Java LinkedList详解源码研究
- java linkedlist操作详解
- java集合(ArrayList,Vector,LinkedList,HashSet,TreeSet的功能详解)
- java集合(ArrayList,Vector,LinkedList,HashSet,TreeSet的功能详解)
- Java LinkedList的实现原理详解
- Java集合之ArrayList和LinkedList的实现原理以及Iterator详解
- java中的ArrayList 、List、LinkedList、Collection关系详解
- java LinkedList的实例详解