Java基础-----集合 List

package cn.itcast.list;

import java.util.ArrayList;

import java.util.List;

/*

 集合的体系：

 -------|collection  单例集合的根接口

 ----------|list 如果是实现了List接口的集合类，该集合类具备的特点：有序，可重复

 ----------|set  如果是实现了Set接口的集合类，该集合类具备的特点：无序不可重复

 

 有序：集合的有序不是指自然顺序，而是指添加进去的顺序与元素出来的顺序一致

 

 List接口中特有的方法：

 添加：

 add(int index，E element)

 addAll(int index，Collection<>)

 获取：

 get(int index)

 indexOf(Object o)

 lastIndexOf(Object o)

 subList(int fromIndex,int toIndex)

 

 修改：

 set(int index,Eelment)

 

 迭代：

   listIterator()

 

 

 

 */

public class Demo1 {
public static void main(String[] args){
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("赵六");
System.out.println("集合的元素："+list);
}

}

package cn.itcast.list;

import java.util.ArrayList;

import java.util.List;

/*List接口中特有的方法：

 添加：

 add(int index，E element)

 addAll(int index，Collection<>)

 获取：

 get(int index)

 indexOf(Object o)

 lastIndexOf(Object o)

 subList(int fromIndex,int toIndex)

 

 修改：

 set(int index,Eelment)

 

 

 List接口中特有的方法具备的特点：操作的方法都存在索引值

 

 只有list接口下面的集合类才具备索引值。其他接口下面的集合类都没有索引值

 

 迭代：

   listIterator()

   

 

   Ctrl+shift+/  添加多行注释

    Ctrl+shift+\  取消多行注释

   */

public class Demo2 {
public static void main(String[] args){
List list = new ArrayList();
list.add("狗娃");
list.add("狗乘");
list.add("铁蛋");//把元素添加到集合的末尾处
list.add("狗娃");

/*//添加方法
list.add(1,"赵本山");//把元素添加到集合中的指定索引值的位置上。

List list2 = new ArrayList();
list2.add("本山");
list2.add("小沈阳");

list.addAll(2,list2);//把list2的元素添加到list集合指定的索引值位置上
*/

/*
获取的方法

//System.out.println("get方法获取元素："+list.get(1));//根据索引值获取集合中的元素
//使用get方法遍历集合的元素：
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i)+",");
}

System.out.println("找出指定元素第一次出现在集合中的索引值："+list.indexOf("本山"));
System.out.println("找指定的元素最后一次出现在集合中的索引值"+list.lastIndexOf("狗娃"));
List subList=list.subList(1, 3);//指定开始与结束的索引值截取集合中的元素。
System.out.println("子集合的元素是："+sublist);

*/

//修改方法
list.set(3, "赵本山");//使用指定的元素替换指定索引值位置的元素
System.out.println("set方法修改元素元素："+list.set(3, "赵本山"));
System.out.println("集合的元素："+list);
}

}

package cn.itcast.list;

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

/*

 迭代：

 

 listrator()

 

 listrator()特有的方法

 

 添加：hasPrevious()  判断是否存在上一个元素。

    previous（） 当前指针先向上移动一个单位，然后再取出当前指针指向的元素。

    

    next()  先取出当前指针指向的元素，然后指针向下移动一个单位

    

    add(E,e)  把当前元素插入到当前指针指向的位置上

    set(E,e)  替换迭代器最后一次返回的元素

    

    

    练习：使用三种方式遍历集合的元素。

    

    第一种：使用get方法遍历

    

 第二种：使用迭代器正顺遍历

 第三种：使用迭代器逆序遍历

  

 */

public class Demo3 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("狗娃");
list.add("狗乘");
list.add("铁蛋");//把元素添加到集合的末尾处
list.add("美美");

ListIterator it = list.listIterator();//返回的是list接口特有的迭代器
/*
System.out.println("有上一个元素么？"+it.hasPrevious());
System.out.println("获取上一个元素："+it.previous());

it.next();
System.out.println("获取上一个元素："+it.previous());

while(it.hasNext()){
it.next();
//System.out.println("元素："+it.previous());
}
while(it.hasPrevious()){
System.out.println(""+it.previous());
}

it.next();
it.next();
it.add("张三");

*/
it.next();
it.next();
it.set("张三");
System.out.println("集合的元素："+list);
}

}

package cn.itcast.list;

/*

   练习：使用三种方式遍历集合的元素。

    

    第一种：使用get方法遍历

    

 第二种：使用迭代器正顺遍历

 第三种：使用迭代器逆序遍历

 

  */

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

public class Demo4 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");

System.out.println("======get方法遍历=====");
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i)+",");
}

System.out.println("\r\n======使用迭代器正序遍历=====");

ListIterator it = list.listIterator();//获得迭代器
while(it.hasNext()){
System.out.println(it.next()+",");

}

System.out.println("\r\n======使用迭代器逆序遍历=====");
while(it.hasPrevious()){
System.out.println(it.previous()+",");

}

}

}

package cn.itcast.list;

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

/*

 迭代器在变量元素的时候要注意的事项：

 

  在迭代器迭代元素的过程中，不允许使用集合对象改变集合中的元素个数，如果需要增加和删除只能使用迭代器的方法进行操作

 如果使用了集合对象改变集合中元素的个数那么就会出现ConcurrentModificationException

 

 

 迭代器迭代元素的过程中：迭代器一旦创建到使用结束的时间。

 */

public class Demo5 {

public static void main(String[] args) {
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");

ListIterator it = list.listIterator();//获取迭代器
/* while(it.hasNext()){
System.out.println(it.next()+",");
it.add("aa");//把元素添加当前指针指向的位置
//list.add("aa");//add方法是把元素添加到集合的末尾处
 报错
}*/

list.add("aa");
it.next();
System.out.println("\r\n元素"+list);

}

}

package cn.itcast.list;

import java.util.ArrayList;

/*

 

  集合的体系：

  

  --------|Collection  单例集合的根接口

  ------------|List   如果实现了List接口的集合类，具备的特点：有序，可重复

  ---------------|ArrayList  ArrayList底层是维护了一个Object数组实现的，特点：查询速度快，增删慢

 什么时候使用Arraylist：如果目前的数据是查询比较多，增删比较少的时候，那么就使用Arraylist存储着批数据：比如高校的图书馆

  

  ---------------|LinkedList

  ---------------|Vector(了解即可)

  

  

  ------------|Set    如果实现了set接口的集合类，具备的特点：无序，不可重复

 

  

  Arra
e63d
yList特有的方法：

  ensureCapacity(int minCapacity)

  trimToSize  将此Arraylist实例的容量调整为列表的当前大小

       

 笔试题目：使用Arraylist无参的构造函数创建一个对象时，默认的容量是多少？如果长度不够用时自动增长多少？

 

 ArrayList底层是维护了一个Object数组实现的，使用无参构造函数是，Object数组默认容量是10，当长度不够用时，自动增长0.5倍

 

 Arraylist的特点原理：查询速度快，增删慢

  

  数组中的元素与元素之间的内存地址是连续的。

 */

public class Demo6 {

public static void main(String[] args) {
ArrayList list = new ArrayList();

}

}

package cn.itcast.list;

/*

需求：编写一个函数清楚集合中重复的元素。如果书号是一样的就视为重复元素。要求：遍历集合元素的时候必须使用迭代器 

 */

import java.util.ArrayList;

import java.util.Iterator;

class Book{
int id;
String name;

public Book(int id,String name){
this.id = id;
this.name = name;
}

@Override
public String toString() {

return "{ 书号："+this.id+"书名："+this.name+"}";
}

@Override
public boolean equals(Object obj) {
Book book = (Book)obj;
return this.id == book.id;
}

}

//需求：编写一个函数清楚集合中重复的元素。如果书号是一样的就视为重复元素。要求：遍历集合元素的时候必须使用迭代器

public class Demo7 {

public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Book(110,"java编程思想"));
list.add(new Book(220,"java核心技术"));
list.add(new Book(330,"java深入javaweb"));
list.add(new Book(110,"java神书"));

ArrayList list2 = clearRepeat(list);
System.out.println("新集合的元素是："+list2);
}
public static ArrayList clearRepeat(ArrayList list){
//创建一个新的集合

ArrayList newList= new ArrayList();

//获取迭代器
Iterator it = list.iterator();
while(it.hasNext()){
Book book = (Book)it.next();//从就集合中获取元素
if(!newList.contains(book)){
//如果新集合没有包含该书籍，那么就存储到新集合中
newList.add(book);
}
}
return newList;
}

}

package cn.itcast.list;

import java.util.Iterator;

import java.util.LinkedList;

/*

  集合的体系：

  

  --------|Collection  单例集合的根接口

  ------------|List   如果实现了List接口的集合类，具备的特点：有序，可重复

  ---------------|ArrayList  ArrayList底层是维护了一个Object数组实现的，特点：查询速度快，增删慢

 什么时候使用Arraylist：如果目前的数据是查询比较多，增删比较少的时候，那么就使用Arraylist存储着批数据：比如高校的图书馆

  

  ---------------|LinkedList  LinkedList 底层是使用了链表的是数据结构实现

  ---------------|Vector(了解即可)

  

  

  ------------|Set    如果实现了set接口的集合类，具备的特点：无序，不可重复

  

  

 1. LinkedList的特有方法：

  

 addFirst(E,e)

 addLast(E,e)

 getFirst()

 getLast()

 removeFirst()

 removeLast()

 

 2.数据结构：

    1.栈（1,6）:主要是用于实现堆栈数据结构的存储方式。

                       先进后出

       push()

       pop()

       2.队列（双端队列1,5）：主要是为了使用Linklist模拟队列的数据结构的存储方式

                        先进先出

       offer()

       poll()

       

3.返回逆序的迭代器对象

descendingIterator()  返回逆序的迭代器对象

  

  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("狗娃");//将该元素插入到集合的开头处
//list.pop();//移除并返回集合中的第一个元素
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());
}

}

}

package cn.itcast.list;

import java.util.LinkedList;

/*

 *

 1.栈（1,6）:主要是用于实现堆栈数据结构的存储方式。

                       先进后出

       push()

       pop()

       2.队列（双端队列1,5）：主要是为了使用LinkedList模拟队列的数据结构的存储方式

                        先进先出

       offer()

       poll()

       

  机试题目：使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式

  

  

 堆栈 数据结构的存储特点：先进后出，后进先出（类似一个桶）

 队列数据结构的存储特点：先进先出，后进后出（类似银行取钱排队）

 */

//使用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());
}

}

}

package cn.itcast.list;

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;
}

}

package cn.itcast.list;

/*

 

 编写一个函数根据人的年龄进行排序存储

 */

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);

}

}

package cn.itcast.list;

import java.util.Enumeration;

import java.util.Vector;

/*

  集合的体系：

  

  --------|Collection  单例集合的根接口

  ------------|List   如果实现了List接口的集合类，具备的特点：有序，可重复

  ---------------|ArrayList  ArrayList底层是维护了一个Object数组实现的，特点：查询速度快，增删慢

 什么时候使用Arraylist：如果目前的数据是查询比较多，增删比较少的时候，那么就使用Arraylist存储着批数据：比如高校的图书馆

  

  ---------------|LinkedList  底层是使用了链表数据结构实现的，特点：查询慢，增删块快

  ---------------|Vector(了解即可)底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低

  

  

  ------------|Set    如果实现了set接口的集合类，具备的特点：无序，不可重复

 笔试题目：说出ArrayList与Vector的区别

 

 相同点：ArrayList与Vector底层都是使用了Object数组实现的

 

 不同点：1.Arraylist是线程不同步的，操作效率高。Vector是线程同步的，操作效率低

      2.ArrayList是JDK1.2出现的，Vector是JDK1.0的时候出现的

 */

public class Demo1 {

public static void main(String[] args) {
Vector v =new Vector();
v.addElement("张三");
v.addElement("李四");
v.addElement("王五");

//迭代集合
Enumeration e = v.elements();
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}

}

}