当前位置： 代码迷 >> 综合 >> Java Day13
  详细解决方案

Java Day13

热度：14   发布时间：2023-12-25 12:23:13.0

第一章 Collection集合

1.1 集合概述

  • 集合：Java中提供的一种容器，可以用来存储多个数据。
  • 集合与数组的区别
    • 数组长度是固定的，集合长度是可变的。
    • 数组中存储的是同一类型的元素，可以存储基本数据类型值，集合存储的都是对象，而且对象的类型可以不一致，在开发中一般当对象多的时候，使用集合进行存储。

1.2 集合的框架

JavaSE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用那一个类，以及类之间如何彼此合作，从而达到灵活应用。

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map，今天我们主要学习Collection集合。

  • Collection：但李集合类的根接口，用于存储一系列集合符合某种规则的元素，它有两个重要的字接口，分别是java.util.List和java.util.Set。其中 List的特点是元素有序，元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。
  • 具体结构如下图：

1.3 Collection 常用功能

Collection是所用单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可以用于操作所有的单列集合，方法如下：

  • public boolean add(E e)：把给定的对象添加到当前集合中。
  • public void clear()：清空集合中所有的元素。
  • public boolean remove(E e)：把给定的对象在当前集合中删除。
  • public boolean contains(E e)：判断当前集合中的是否包含给定的对象。
  • public boolean isEmpty()：判断当前集合是否为空。
  • public int size()：返回集合中元素个数。
  • public Object[] toArray()：把集合中的元素，存储到数组中。

代码如下：

/*
* java.util.Collection接口
*   所有单列集合最顶层的接口，里边定义 了所有单列集合共性的方法。
*   注意：任意的单列集合都可以使用Collection接口中的方法。
*
* 共性的方法：
*   public boolean add(E e)：把给定的对象添加到当前的集合中。
*   public void clear()：清空集合中所有的元素。
*   public boolean remove(E e)：把给定的对象在当前集合中删除。
*   public boolean contains(E e)：判断当前集合中是否包含给定的对象。
*   public boolean isEmpty()：判断当前集合是否为空。
*   public int size()：返回集合中元素的个数。
*   public Object[] toArray()：把集合中的元素，存储到数组中。
* */import java.util.ArrayList;
import java.util.Collection;public class Demo01Collection {public static void main(String[] args) {// 创建集合对象，可以使用多态Collection<String> coll = new ArrayList<>();System.out.println(coll);  // 重写了toString方法 []/** public boolean add(E e)：把给定的对象添加到当前集合中。* 返回值是一个boolean值，一般都返回true，所以可以不用接收。* */boolean b1 = coll.add("tiger");System.out.println(b1);  // trueSystem.out.println(coll);  // [tiger]coll.add("trony");coll.add("hhhhh");System.out.println(coll);  // [tiger, trony, hhhhh]/** pubilc boolean remove(E e)：把给定的对象在当前集合中删除。* 返回值是一个boolean值，集合中存在元素，删除元素，返回true*                     集合中不存在元素，删除失败，返回false** */boolean b2 = coll.remove("hhhhh");System.out.println("b2:" + b2);boolean b3 = coll.remove("hihih");System.out.println("b3:" + b3);System.out.println(coll);  // [tiger, trony]/** public boolean contains(E a)：判断当前集合中是否包含给定的对象。* 包含返回true* 不包含返回false* */boolean b4 = coll.contains("trony");System.out.println("b4:" + b4);  // trueboolean b5 = coll.contains("haoifhdo");System.out.println("b5:" + b5);  // false// public boolean isEmpty()：判断当前集合是否为空。boolean b6 = coll.isEmpty();System.out.println(b6);// public int size()：返回集合中元素的个数。int size = coll.size();System.out.println(size);  // 2// public Object[] toArray()：把集合中的元素，存储到数组中。Object[] arr = coll.toArray();for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}// public void clear()：清空集合中所有的元素。但是不删除集合，集合还在coll.clear();System.out.println(coll);System.out.println(coll.isEmpty());}
}

第二章 迭代器

2.1 Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合的一员，但它与Collection，Map接口所有不同，Collection接口与Map接口主要是用于存储元素，而Iterator接口主要用于迭代访问Collection中的元素，因此Iterator对象也被成为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

  • public Iterator iterator()：获取集合对应的迭代器，用来遍历集合中的元素。

下面介绍一下迭代的概念：

  • 迭代：即Collection集合元素的通用获取方式。在取出元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

  • public E next()：返回迭代的下一个元素。
  • public boolean hasNext()：如果仍有元素可以迭代，返回true。
  • 代码如下：
package com.it.day02code.demo02.Iterator;/*
* java.util.Iterator接口：迭代器（对集合进行遍历）
* 有两个常用方法：
*   boolean hasNext()：判断集合中还有没有下一个元素，有就返回true，没有就返回false
*   E next()：取出集合中的下一个元素
*
* Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
* Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象。
*   Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
* 迭代器的使用步骤：
*   1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)。
*   2、使用Iterator接口中的方法hasNext()判断还有没有下一个元素。
*   3、使用Iterator接口中的方法next取出集合中的下一个元素。
*
* */import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class Demo01Iterator {public static void main(String[] args) {// 创建一个集合对象Collection<String> coll = new ArrayList<>();// 往集合中添加元素coll.add("姚明");coll.add("tiger");coll.add("trony");coll.add("hahaha");/** 1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iteraator接口接收（多态）* 注意：*   Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型* */// 多态  接口           实现类对象Iterator<String> it = coll.iterator();// 使用Iterator接口中的方法hasNext判断还有没有下一个元素
//        boolean b = it.hasNext();
//        System.out.println(b);  // true
//        // 使用Iterator接口中的方法next取出集合中的下一个元素
//        String s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        // 没有元素就会抛出NoSachElementexception异常
//        // s = it.next();// 使用循环优化迭代器取出元素的代码while(it.hasNext()) {System.out.println(it.next());}System.out.println("=========================");for (Iterator<String> it2 = coll.iterator(); it2.hasNext();) {System.out.println(it2.next());}}}

2.2 迭代器的实现原理

我们在之前案例已经完成了iterator遍历集合的整个过程。当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已经到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，工作原理如下：

在调用iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，以此类推，直到hasNext返回false，表示到达了集合的末尾，终止循环。

2.3 增强for

增强for循环（也称for each循环）是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理就是个iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行，增删操作。

代码如下：

package com.it.day02code.demo02.Iterator;/*
* 增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写。
* 是JDK1.5之后出现的新特性
* Collection<E> extends Iterable<E>：所有的单列集合都可以使用增强for
* public interface Iterable<T> 实现这个接口允许对象成为 "foreach" 语句的目标
*
* 增强for循环：用来遍历集合和数组
*
* 格式：
*   for(集合/数组的数据类型 变量名; 集合名/数组名) {
*       sout(变量名);
*   }
*
* 注意：增强for循环必须有遍历的目标，目标必须是数组或集合
* */import java.util.ArrayList;public class Demo02Foreach {public static void main(String[] args) {// demo01();demo02();}private static void demo02() {ArrayList<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");list.add("ddd");list.add("eee");for (String s : list) {System.out.println(s);}}// 使用增强for循环遍历数组private static void demo01() {int[] arr = {1, 2, 3, 4, 5};for(int i : arr) {System.out.println(i);}}}

第三章 泛型

3.1 泛型概述

在前面学习集合的时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们就会被提升成为Object类型，当我们取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

请看下面代码：

import java.util.ArrayList;
import java.util.Iterator;public class Demo01Generic {public static void main(String[] args) {show01();show02();}/** 创建集合对象使用泛型* 好处：*   1、避免了类型转换的麻烦，存储是什么类型，取出就是什么类型*   2、把运行期异常（代码运行之后才会抛出的的异常），提升到了编译其（写代码的时候就会报错）* 弊端：*   泛型是什么类型，只能存储什么类型的数据** */private static void show02() {ArrayList<String> list = new ArrayList<>();list.add("abc");// 使用迭代器遍历集合Iterator<String> it = list.iterator();while (it.hasNext()) {String s = it.next();System.out.println(s + "->" + s.length());}}/** 创建集合对象不使用泛型* 好处：*   集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据* 弊端：*   不安全，会引发异常* */private static void show01() {ArrayList list = new ArrayList();list.add("abc");list.add(1);// 使用迭代器遍历list集合// 获取迭代器Iterator it = list.iterator();// 使用迭代器中的hasnext()方法和next()方法来遍历集合while (it.hasNext()) {// 取出元素也是Object类型Object obj = it.next();System.out.println(obj);// 想要使用String类特有的方法，length获取字符串的长度：不能使用 多态// 需要向下转型// 会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型。// String s = (String)obj;// System.out.println(s.length());}}}

程序在运行时发生了问题java.lang.ClassException。这时由于集合中什么类型元素都可以存储。导致取出时强转引发运行时，ClassCastException。虽然Collection可以存储各种对象，但实际上通常Collection只存储同一类型的对象。因此，在JDK5之后增加了泛型语法，让我们在设计API的时候可以指定类或方法支持泛型，这样我们使用API也变得更为简洁，并得到了编译时期的语法检查。

  • 泛型：可以在类或方法中预支的使用未知的类型。

3.2 使用泛型的好处

  • 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
  • 避免了类型强转。

代码如下：

package com.it.day02code.demo03.Generic;public class Demo02GenericClass {public static void main(String[] args) {// 不写泛型默认为object类型GenericClass gc = new GenericClass();gc.setName("tiger");Object obj = gc.getName();// 创建GenericClass对象，泛型使用Integer类型GenericClass<Integer> gc2 = new GenericClass<>();gc2.setName(1);Integer name = gc2.getName();System.out.println(name);}
}

3.3 泛型的定义与使用

泛型，用来灵活的将数据类型应用到不同的类，方法，接口当中。将数据类型作为参数传递。

3.3.1 定义和使用含有泛型的类

  • 定义格式：
修饰符 class 类名<代表泛型的变量> {}
  • 例如：
class ArrayList<E> {public boolean add(E e) {}public E get(int index) {}...}
  • 代码如下：

定义一个泛型类：

/*
* 定义一个含有泛型的类，模拟ArrayList集合
* 泛型是一个未知的数据类型，当我们不确定是什么数据类型的时候，可以使用泛型
* 泛型可以接收任意的数据类型
* 创建对象的时候确定泛型的数据类型
*
* */public class GenericClass<E> {private E name;public E getName() {return name;}public void setName(E name) {this.name = name;}
}

定义一个测试类：

public class Demo02GenericClass {public static void main(String[] args) {// 不写泛型默认为object类型GenericClass gc = new GenericClass();gc.setName("tiger");Object obj = gc.getName();// 创建GenericClass对象，泛型使用Integer类型GenericClass<Integer> gc2 = new GenericClass<>();gc2.setName(1);Integer name = gc2.getName();System.out.println(name);}
}

3.3.2 含有泛型的方法

  • 定义格式
修饰符 <代表泛型的变量> 返回值类型 方法名(参数) { }
  • 代码如下：
package com.it.day02code.demo03.Generic;/*
* 测试含有泛型的方法
* */public class Demo03GenericMethod {public static void main(String[] args) {// 创建一个GenericMethod对象GenericMethod gm = new GenericMethod();/** 调用含有泛型的方法method01* 传递什么类型，泛型就是什么类型* */gm.method01(10);gm.method01("abc");gm.method01(8.8);gm.method01("静态方法不建议创建对象使用");// 静态方法，通过类名.方法名(参数)可以直接使用GenericMethod.method02("静态方法");GenericMethod.method02(1);}
}

3.3.3 含有泛型的接口

  • 定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数) {  }
  • 代码如下：

定义含有泛型的接口：

package com.it.day02code.demo03.Generic;/*
* 定义含有泛型的接口
*
* */public interface GenericInterface<I> {public abstract void method(I i);
}

定义实现类的第一种方式：

/*
* 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。
*
* */public class GenericInterfaceImpl implements GenericInterface<String> {@Overridepublic void method(String s) {System.out.println(s);}
}

定义实现类的第二种方式：

/*
* 含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
* 就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类
*
* */public class GenericInterfaceImpl2<I> implements GenericInterface<I> {@Overridepublic void method(I i) {System.out.println(i);}
}

定义测试类：

/*
* 测试含有泛型的接口
*
*
* */public class Demo04GenericInterface {public static void main(String[] args) {// 创建GenericInterfaceImpl对象GenericInterfaceImpl gi1 = new GenericInterfaceImpl();gi1.method("string");// 创建GenericIntegerfaceImpl2对象GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();gi2.method(10);GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();gi3.method(8.8);}
}

3.4 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用。

3.4.1 通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，鄙视可以使用“ ？”，“ ？”表示未知通配符。

此时只能接受数据，不能往该集合中存储数据。

例如：

import java.util.ArrayList;
import java.util.Iterator;public class Demo05Generic {public static void main(String[] args) {ArrayList<Integer> list01 = new ArrayList<>();list01.add(1);list01.add(2);ArrayList<String> list02 = new ArrayList<>();list02.add("a");list02.add("b");}/** 定义一个方法，能遍历所有类型的ArrayList集合* 这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符？来接收数据类型* 注意：*   泛型没有继承概念的** */public static void printArray(ArrayList<?> list) {// 使用迭代器遍历集合Iterator<?> it = list.iterator();while (it.hasNext()) {// it.next()方法取出的元素是object，可以接收任意的数据类型Object o = it.next();System.out.println(o);}}}

3.4.2 通配符的高级使用——受限泛型

在前面我们设置泛型的时候，实际上是任意设置的，只要是类就可以设置，但是在Java的泛型中可以指定一个泛型的上下限。

泛型的上限：

  • 格式：类型名称<? extends 类 > 对象名称
  • 意义：只能接收该类型及其子类。

泛型的下限：

  • 格式：类型名称<? super 类> 对象名称
  • 意义：只能接收该类型及其父类。

第四章 集合综合案例

4.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作，具体规则：使用54张牌打乱顺序，三个玩家参与游戏，三人交替摸牌，没人17张牌，最后三张留作底牌。

4.1 代码实现

import java.util.ArrayList;
import java.util.Collections;public class FightLordMain {public static void main(String[] args) {String[] flower = {"??", "??", "??", "??"};String[] number = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};ArrayList<String> squeezers = new ArrayList<>();for (int i = 0; i < flower.length; i++) {for (int j = 0; j < number.length; j++) {String squeezer = flower[i] + number[j];squeezers.add(squeezer);}}squeezers.add("大王");squeezers.add("小王");Collections.shuffle(squeezers);ArrayList<String> p1 = new ArrayList<>();ArrayList<String> p2 = new ArrayList<>();ArrayList<String> p3 = new ArrayList<>();ArrayList<String> cards = new ArrayList<>();for (int i = 1; i < 4; i++) {cards.add(squeezers.get(squeezers.size()-i));}for (int i = 0; i < squeezers.size() - 3; i++) {if(i % 3 == 0) {p1.add(squeezers.get(i));} else if (i % 3 == 1) {p2.add(squeezers.get(i));} else if (i % 3 == 2) {p3.add(squeezers.get(i));}}System.out.println(p1.toString());System.out.println(p2.toString());System.out.println(p3.toString());System.out.println(cards);}
}

 

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.