Java语言程序设计——篇十一(2)

avatar
作者
筋斗云
阅读量:0

在这里插入图片描述
在这里插入图片描述

       🌿🌿🌿跟随博主脚步,从这里开始→博主主页🌿🌿🌿

  • 欢迎大家:这里是我的学习笔记、总结知识的地方,喜欢的话请三连,有问题可以私信🌳🌳🌳
    您的点赞👍、关注➕、收藏⭐️、评论📝、私信📧是我最大的支持与鼓舞!!!🌻🌻🌻

🚩集合——List

集合框架

  • 集合框架是Java以类库的形式提供了用户开发程序时可直接使用的各种数据结构
  • 数据结构:以某种形式将数据组织在一起,不仅支持存储数据,还支持访问和处理数据。
  • 在面向对象思想里,一种数据结构被认为是一个容器(集合)。
  • Java集合框架提供了一些现成的数据结构可供使用,这些数据结构是可以存储对象的集合,在这里对象也称为元素。
  • Java集合框架由两种类型构成:
        1️⃣Collection,用于存放一组对象。
        2️⃣Map ,用于存放一组“关键字/值”的对象。
    在这里插入图片描述
  1. 基本操作
    boolean add(E e):向集合中添加元素e
    boolean remove(Object o):从集合中删除指定的元素o
    boolean contains(Object o):返回集合中是否包含指定元素
    boolean isEmpty():判空
    int size():返回集合中所包含元素的个数
    Iterator iterator():返回包含所有元素的迭代器对象
  2. 批量操作
    boolean addAll(Collection<? extends E> c) 功能:将集合c中的所有元素添加到当前集合中 boolean removeAll(Collection<?> c)
    功能:从当前集合中删除集合c中的所有元素
    default boolean removeIf(Predicate<? super E> filter)
    功能:从当前集合中删除满足谓词的所有元素
  3. 数组操作
    Object[] toArray() :用来返回包含集合中所有元素的Object型数组
    eg: Object[] a = c.toArray();
    T[] toArray(T[] a):用来返回包含集合中所有元素的指定类型的数组
    eg: String[] a = c.toArray(new String[0]);
  4. 流(Stream)操作
    default Stream stream()
    功能:以当前集合作为源返回一个顺序Stream对象
    default Stream parallelStream()
    功能:以当前集合作为源返回一个并行Stream对象

List接口及实现类

  • 列表接口List是Collection的子接口,它是一种包含有序元素的线性表,其中的元素可重复,也可以是空值null。
  • 存放在List中的元素有一个下标(从0开始),可通过下标访问List中的元素。
  • 在这里插入图片描述

在这里插入图片描述

List的操作

  • 因为List接口为Collection的子接口,所以List接口拥有Collection接口提供的所有常用方法。
  • List是列表类型,它还提供了一些适合于自身的常用方法,如下页表所示。
方 法 名 称功 能 简 介
void add(int index, E obj)用来向列表的指定索引位置添加对象,其他对象的索引位置相对后移一位。索引位置从0开始
E remove(int index)用来清除列表中指定索引位置的对象
E set(int index, E obj)用来将列表中指定索引位置的对象修改为指定的对象
E get(int index)用来获得指定索引位置的对象
int indexOf(Object obj)用来获得指定对象的第一个索引位置。当不存在时,返回-1
int lastIndexOf(Object obj)用来获得指定对象的最后一个索引位置。当不存在时,返回-1
List <?> subList(int from, int to)返回从from(包含)到to(不包含)的一个List列表
listIterator()用来获得一个包含所有对象的ListIterator型实例

ArrayList类

  • List接口的常用实现类有ArrayList和LinkedList,在使用线性表时,通常情况下声明为List类型,实例化时根据实际情况的需要,实例化为ArrayList或LinkedList。
  • 例如:
// 利用ArrayList类实例化List List<String> list1 = new ArrayList<String>();   // 利用LinkedList类实例化List List<String> list2 = new LinkedList<String>();  
  • ArrayList类是通过数组实现的集合对象,它实际上实现了一个变长的对象数组,元素可以动态的增加和删除。
  • 数组结构的优点是便于对列表进行快速的随机访问, 如果经常需要根据索引位置访问集合中的对象,使用ArrayList类实现的列表的效率较高。
  • 数组结构的缺点是向指定索引位置插入对象、删除指定索引位置对象的速度较慢。
  • 当在指定索引位置插入对象时,会将指定索引位置及其后的所有元素相应地向后移动一位,如下图所示:
    在这里插入图片描述
  • 删除指定索引位置的对象时,会将指定索引位置之后的所有元素相应地向前移动一位,如下图所示: 在这里插入图片描述
  • 进行插入、删除操作时,如果在指定的索引位置之后有大量的对象,将严重影响对集合的操作效率。
  • ArrayList类的构造方法
public ArrayList():创建初始容量为10的空数组列表 public ArrayList(int i):创建初始容量为i的空数组列表 public ArrayList(Collection c):创建包含容器c中所有元素的数组列表 

实战演练

例:TestArrayList.java

import java.util.ArrayList; public class TestArrayList { public static void main(String[] args) {    ArrayList<String> cityList = new ArrayList<>();    //add some cities in the list    cityList.add("Beijing");    //cityList now contains[Beijing]    cityList.add("London");    //cityList now contains[Beijing,London]    cityList.add("Shanghai");    //cityList now contains[Beijing,London,Shanghai]    cityList.add(" Beijing");    //cityList now contains[Beijing,London,Shanghai, Beijing]    cityList.add("Taiyuan");    //cityList now contains[Beijing,London,Shanghai, Beijing,Taiyuan]    System.out.println("List size="+cityList.size());    System.out.println("Is Taiyuan in the list?"+cityList.contains("Taiyuan"));    System.out.println("The location of Shanghai in the list?"+cityList.indexOf("Shanghai"));    System.out.println("Is the list empty?"+cityList.isEmpty());    cityList.add(2, "Xian");  // [Beijing,London,Xian,Shanghai, Beijing,Taiyuan]    cityList.remove(Shanghai"); // [Beijing,London,Xian,Beijing,Taiyuan]    cityList.remove(1); // [Beijing,Xian,Beijing,Taiyuan]    System.out.println(cityList.toString());      for(int i=cityList.size()-1;i>=0;i--) 	System.out.print(cityList.get(i)+" ");    } } 

在这里插入图片描述

遍历集合元素

  • 对集合中元素访问时,经常需要按某种次序对每一个元素访问且仅访问一次,这就是遍历,也称迭代。
  • 对集合元素遍历有如下4种方式:
    a.简单的for循环
   for(int i=0; i<array.size(); i++) String o = array.get(i); 

b.增强的for循环

    for(String elm:array)  System.out.println(elm) 

c.Iterator迭代器对象
d.ListIterator迭代器对象

c.Iterator迭代器对象

  • 每个实现Collection接口的容器对象都可调用iterator()方法返回一个Iterator对象,称为迭代器对象。
  • 接口Iterator支持对List对象的从前向后的遍历,该接口定义了3个方法。
  • 1)boolean hasNext():返回迭代器是否有下一个元素
    2)E next(): 返回下一个元素
    3)void remove():删除迭代器中的当前元素
Iterator iterator = array.iterator(); //得到迭代器对象 while(iterator.hasNext())       System.out.println(iterator.next()); 

               在这里插入图片描述

for(Iterator iterator = array.iterator(); iterator.hasNext();)       System.out.println(iterator.next()); 

d.ListIterator迭代器对象

  • 通过List接口提供的listIterator()方法可以返回ListIterator对象,它支持对线性表双向遍历。
  • ListIterator是Iterator的子接口,不但继承了Iterator接口中的方法,还定义了多个方法。
boolean hasNext() :返回是否还有下一个元素 boolean hasPrevious() :返回是否还有前一个元素 E next():返回下一个元素 E previous():返回前一个元素 int nextIndex():返回下一个元素的索引 int previousIndex():返回前一个元素的索引 void add(E o):当前位置插入一个元素 void remove():删除当前元素 void set(E o):修改当前元素 

实战演练

例:使用ListIterator对象实现反向输出线性表中的元素。

import java.util.*; public class IteratorDemo{     public static void main(String[] args) {          List<String> myList = new ArrayList<String>();      myList.add("one");      myList.add("two");      myList.add("three");      myList.add("four");      ListIterator<String> iterator = myList.listIterator();       // 将迭代器指针移动到线性表末尾      while(iterator.hasNext()){                    iterator.next();               }               // 从后向前访问线性表的每个元素               while (iterator.hasPrevious())                    System.out.println(iterator.previous());      } } 

在这里插入图片描述

数组转换为List对象

  • java.util.Arrays类提供了一个asList()方法,它将数组转换成List对象,定义如下:
public static <T> List<T> asList(T… a)参数可以为数组,可以是数组元素 String[] str = {"one", "two", "three"}; List<String> list = Arrays.asList(str); List<String> list = Arrays.asList("one", "two", "three"); 
  • Arrays.asList()方法返回的List对象不可变。若要对该List对象进行添加、删除等操作,可以将其作为参数传递给另一个List的构造方法。
List<String> list1 = new ArrayList<>(list); 
综合实例

编写程序,实现一个对象栈类MyStack,要求使用ArrayList类实现该栈,该栈类的UML图如下所示。
在这里插入图片描述

import java.util.ArrayList;   import java.util.List;      public class MyStack<T> {       private List<T> list;          // 构造函数       public MyStack() {           list = new ArrayList<>();       }          // 判断栈是否为空       public boolean isEmpty() {           return list.isEmpty();       }          // 返回栈的大小       public int getSize() {           return list.size();       }          // 返回栈顶元素但不移除       public T peek() {           if (isEmpty()) {               throw new IllegalStateException("Stack is empty");           }           return list.get(list.size() - 1);       }          // 弹出栈顶元素       public T pop() {           if (isEmpty()) {               throw new IllegalStateException("Stack is empty");           }           return list.remove(list.size() - 1);       }          // 元素入栈       public void push(T t) {           list.add(t);       }          // 元素查找方法,返回元素在栈中的位置(从栈底开始计数,即第一个元素位置为0),如果未找到则返回-1       public int search(T t) {           for (int i = 0; i < list.size(); i++) {               if (list.get(i).equals(t)) {                   return i; // 注意这里返回的是从栈底开始的位置               }           }           return -1; // 未找到       }          // 可选:打印栈内容(用于调试)       public void printStack() {           System.out.println("Stack content (bottom to top):");           for (int i = 0; i < list.size(); i++) {               System.out.println(list.get(i));           }       }          // 主函数,用于测试MyStack类       public static void main(String[] args) {           MyStack<Integer> stack = new MyStack<>();           stack.push(1);           stack.push(2);           stack.push(3);              System.out.println("Stack size: " + stack.getSize());           System.out.println("Top element: " + stack.peek());           System.out.println("Popped element: " + stack.pop());           System.out.println("Element 2 position: " + stack.search(2));              stack.printStack();       }   } 

博主用心写,读者点关注,互动传真情,知识不迷路。

广告一刻

为您即时展示最新活动产品广告消息,让您随时掌握产品活动新动态!