javaSE第十六天
a:Vector存储字符串并遍历（与ArrayList案例代码相似） 143
b:Vector存储自定义对象并遍历（与ArrayList案例代码相似） 143
a:LinkedList存储字符串并遍历（与ArrayList案例代码相似） 145
b:LinkedList存储自定义对象并遍历（与ArrayList案例代码相似） 145
C:用LinkedList模拟一个栈数据结构的集合类，并测试。(重点理解) 149
B:产生10个1-20之间的随机数，要求随机数不能重复 166
C:键盘录入多个数据，以0结束，并在控制台输出最大值 167
第十六天
1:List的子类(掌握)
(1)List的子类特点
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高，允许添加null值
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高，允许添加null值
(2)ArrayList
A:没有特有功能需要学习
说明：ArrayList中允许插入null值，而且可以插入多个，最终集合中存储着所有
你插入的null
B:案例
a:ArrayList存储字符串并遍历
|
import java.util.ArrayList; import java.util.Iterator;
/* * List的子类特点： * ArrayList: * 底层数据结构是数组，查询快，增删慢 * 线程不安全，效率高 * Vector: * 底层数据结构是数组，查询快，增删慢 * 线程安全，效率低 * LinkedList: * 底层数据结构是链表，查询慢，增删快 * 线程不安全，效率高 * * 案例： * 使用List的任何子类存储字符串或者存储自定义对象并遍历。 * * ArrayList的使用。 * 存储字符串并遍历 */ class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 创建元素对象，并添加元素 array.add("hello"); array.add("world"); array.add("java");
// 遍历 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); }
System.out.println("-----------");
for (int x = 0; x < array.size(); x++) { String s = (String) array.get(x); System.out.println(s); } } } |
b:ArrayList存储自定义对象并遍历
|
import java.util.ArrayList; import java.util.Iterator;
/* * ArrayList存储自定义对象并遍历 */ 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("林冲", 36); Student s4 = new Student("杨志", 38);
// 添加元素 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++) { // ClassCastException 注意，千万要搞清楚类型 // String s = (String) array.get(x); // System.out.println(s);
Student s = (Student) array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } } |
(3)Vector
A:有特有功能
a:添加
public
synchronized
void addElement(E obj) -- 被add()替代
向集合中添加一个元素
b:获取
public
synchronized E elementAt(int
index) -- 被get()替代
获取指定位置的元素
public Enumeration<E> elements() -- 被iterator()替代
返回集合中所有的元素
B:案例
a:Vector存储字符串并遍历（与ArrayList案例代码相似）
b:Vector存储自定义对象并遍历（与ArrayList案例代码相似）
c:Vector的方法演示
|
import java.util.Enumeration; import java.util.Vector;
/* * Vector的特有功能： * 1：添加功能 * public void addElement(Object obj) -- add() * 2：获取功能 * public Object elementAt(int index) -- get() * public Enumeration elements() -- Iterator iterator() * boolean hasMoreElements() hasNext() * Object nextElement() next() * * JDK升级的原因： * A:安全 * B:效率 * C:简化书写 */ class VectorDemo { public static void main(String[] args) { // 创建集合对象 Vector v = new Vector();
// 添加功能 v.addElement("hello"); v.addElement("world"); v.addElement("java");
// 遍历 for (int x = 0; x < v.size(); x++) { String s = (String) v.elementAt(x); System.out.println(s); }
System.out.println("------------------");
Enumeration en = v.elements(); // 返回的是实现类的对象 while (en.hasMoreElements()) { String s = (String) en.nextElement(); System.out.println(s); } } } |
(4)LinkedList
说明：LinkedList允许插入null值，而且可以插入多个null值，最终集合中存储着你插入的所有null值
A:有特有功能
a:添加
public
void addFirst(E e)：在集合的头部添加一个元素
public
void addLast(E e)：在集合的尾部添加一个元素
b:删除
public E removeFirst()：删除集合中第一个元素，并返回被删除的元素
public E removeLast()：删除集合中最后一个元素，并返回被删除的元素
c:获取
public E getFirst()：获取集合中的第一个元素
public E getLast()：获取集合中的最后一个元素
B:案例
a:LinkedList存储字符串并遍历（与ArrayList案例代码相似）
b:LinkedList存储自定义对象并遍历（与ArrayList案例代码相似）
c:LinkedList方法演示
|
import java.util.LinkedList;
/* * LinkedList的特有功能： * A:添加功能 * public void addFirst(Object e) ：在集合的头部添加一个元素 * public void addLast(Object e) ：在集合的末尾添加一个元素 * B:获取功能 * public Object getFirst() ：获取集合中的第一个元素 * public Obejct getLast() ：获取集合中的最后一个元素 * C:删除功能 * public Object removeFirst()：删除集合中的第一个元素，并返回被删除的元素 * public Object removeLast()：删除集合中的最后一个元素，并返回被删除的元素 */ class LinkedListDemo { public static void main(String[] args) { // 创建集合对象 LinkedList link = new LinkedList();
// 添加元素 link.add("hello"); link.add("world"); link.add("java");
// public void addFirst(Object e) ：在集合的头部添加一个元素 // link.addFirst("javaee"); // public void addLast(Object e) ：在集合的末尾添加一个元素 // link.addLast("android");
// public Object getFirst() ：获取集合中的第一个元素 // System.out.println("getFirst:" + link.getFirst()); // public Obejct getLast() ：获取集合中的最后一个元素 // System.out.println("getLast:" + link.getLast());
// public Object removeFirst()：删除集合中的第一个元素，并返回被删除的元素 System.out.println("removeFirst:" + link.removeFirst()); // public Object removeLast()：删除集合中的最后一个元素，并返回被删除的元素 System.out.println("removeLast:" + link.removeLast());
// 输出对象名 System.out.println("link:" + link); } } |
(5)案例：
A:去除集合中的多个字符串的重复元素
如果字符串的内容相同，即为重复元素
方式一：用新集合存储未重复元素
|
import java.util.ArrayList; import java.util.Iterator;
/* * 案例：ArrayList去除集合中字符串的重复值(字符串的内容相同) * * 分析： * A:创建集合对象 * B:添加多个字符串元素(包含内容相同的) * C:创建新集合 * D:遍历旧集合,获取得到每一个元素 * E:拿这个元素到新集合去找，看有没有 * 有：不搭理它 * 没有：就添加到新集合 * F:遍历新集合 */ class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world");
// 创建新集合 ArrayList newArray = new ArrayList();
// 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next();
// 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } }
// 遍历新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } } } |
方式二：在老集合上面进行重复元素的删除
|
import java.util.ArrayList; import java.util.Iterator;
/* * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同) * 要求：不能创建新的集合，就在以前的集合上做。 */ class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world");
// 由选择排序思想引入，我们就可以通过这种思想做这个题目 索引的依次和后面的比较，有就把后的干掉 索引... 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--;// 这里是关键点 } } }
// 遍历集合 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } } |
B:去除集合中的多个自定义对象的重复元素
如果自定义对象的成员变量值都相同，即为重复元素
|
import java.util.ArrayList; import java.util.Iterator;
/* * 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同) * 要求：不能创建新的集合，就在以前的集合上做。 */ class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world");
// 由选择排序思想引入，我们就可以通过这种思想做这个题目 索引的依次和后面的比较，有就把后的干掉 索引... 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--;// 这里是关键点 } } }
// 遍历集合 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } } |
C:用LinkedList模拟一个栈数据结构的集合类，并测试。(重点理解)
你要定义一个集合类，只不过内部可以使用LinkedList来实现。
|
import java.util.LinkedList;
/* *请用LinkedList模拟栈数据结构的集合，并测试 *题目的意思是： * 你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。 */
/* * MyStack的测试 */ class MyStackDemo { public static void main(String[] args) { // 创建集合对象 MyStack ms = new MyStack();
// 添加元素 ms.add("hello"); ms.add("world"); ms.add("java");
// System.out.println(ms.get()); // System.out.println(ms.get()); // System.out.println(ms.get()); // NoSuchElementException // System.out.println(ms.get());
while (!ms.isEmpty()) { System.out.println(ms.get()); } } }
/** * 自定义的栈集合 模拟了栈先进后出的特点，但是底层任然是调用 LinkedList类的方法 * * @author * @version V1.0 */ class MyStack { private LinkedList link;
public MyStack() { link = new LinkedList(); }
public void add(Object obj) { link.addFirst(obj); }
public Object get() { // return link.getFirst(); return link.removeFirst(); }
public boolean isEmpty() { return link.isEmpty(); } } |
2:泛型(掌握)
(1)泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
<数据类型>
注意：该数据类型只能是引用类型。
(3)好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型介绍的代码演示
|
import java.util.ArrayList; import java.util.Iterator;
/* * ArrayList存储字符串并遍历 * * 我们按照正常的写法来写这个程序， 结果确出错了。 * 为什么呢? * 因为我们开始存储的时候，存储了String和Integer两种类型的数据。 * 而在遍历的时候，我们把它们都当作String类型处理的，做了转换，所以就报错了。 * 但是呢，它在编译期间却没有告诉我们。 * 所以，我就觉得这个设计的不好。 * 回想一下，我们的数组 * String[] strArray = new String[3]; * strArray[0] = "hello"; * strArray[1] = "world"; * strArray[2] = 10; * 集合也模仿着数组的这种做法，在创建对象的时候明确元素的数据类型。这样就不会在有问题了。 * 而这种技术被称为：泛型。 * * 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。 参数化类型，把类型当作参数一样的传递。 * 格式： * <数据类型> * 此处的数据类型只能是引用类型。 * 好处： * A:把运行时期的问题提前到了编译期间 * B:避免了强制类型转换 * C:优化了程序设计，解决了黄色警告线 */ class GenericDemo { public static void main(String[] args) { // 创建 ArrayList<String> array = new ArrayList<String>();
// 添加元素 array.add("hello"); array.add("world"); array.add("java"); // array.add(new Integer(100)); // array.add(10); // JDK5以后的自动装箱 // 等价于：array.add(Integer.valueOf(10));
// 遍历 Iterator<String> it = array.iterator(); while (it.hasNext()) { // ClassCastException // String s = (String) it.next(); String s = it.next(); System.out.println(s); }
// 看下面这个代码 // String[] strArray = new String[3]; // strArray[0] = "hello"; // strArray[1] = "world"; // strArray[2] = 10; } } |
(5)泛型的前世今生
A:泛型的由来
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
B:泛型类
泛型定义在类上面
|
/* * 泛型类：把泛型定义在类上 */ class ObjectTool<T> { private T obj;
public T getObj() { return obj; }
public void setObj(T obj) { this.obj = obj; } }
/* * 泛型类的测试 */ class ObjectToolDemo { public static void main(String[] args) {
ObjectTool<String> ot = new ObjectTool<String>(); // ot.setObj(new Integer(27)); //这个时候编译期间就过不去 ot.setObj(new String("林青霞")); String s = ot.getObj(); System.out.println("姓名是：" + s);
ObjectTool<Integer> ot2 = new ObjectTool<Integer>(); // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去 ot2.setObj(new Integer(27)); Integer i = ot2.getObj(); System.out.println("年龄是：" + i); } } |
C:泛型方法
|
/* * 泛型方法：把泛型定义在方法上 */ class ObjectTool { public <T> void show(T t) { System.out.println(t); } }
/* * 泛型方法的测试 */ class ObjectToolDemo { public static void main(String[] args) { // ObjectTool ot = new ObjectTool(); // ot.show("hello"); // ot.show(100); // ot.show(true);
// ObjectTool<String> ot = new ObjectTool<String>(); // ot.show("hello"); // // ObjectTool<Integer> ot2 = new ObjectTool<Integer>(); // ot2.show(100); // // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>(); // ot3.show(true);
// 如果还听得懂，那就说明泛型类是没有问题的 // 但是呢，谁说了我的方法一定要和类的类型的一致呢? // 我要是类上没有泛型的话，方法还能不能接收任意类型的参数了呢?
// 定义泛型方法后 ObjectTool ot = new ObjectTool(); ot.show("hello"); ot.show(100); ot.show(true); } } |
D:泛型接口
|
/* * 泛型接口：把泛型定义在接口上 */ interface Inter<T> { public abstract void show(T t); }
//实现类在实现接口的时候 //第一种情况：已经知道是什么类型的了（说明；这种情况很罕见）
//public class InterImpl implements Inter<String> { // // @Override // public void show(String t) { // System.out.println(t); // } //}
//第二种情况：还不知道是什么类型的（说明：这种情况比较常见） class InterImpl<T> implements Inter<T> {
@Override public void show(T t) { System.out.println(t); } }
class InterDemo { public static void main(String[] args) { // 第一种情况的测试 // Inter<String> i = new InterImpl(); // i.show("hello");
// 第二种情况的测试 Inter<String> i = new InterImpl<String>(); i.show("hello");
Inter<Integer> ii = new InterImpl<Integer>(); ii.show(100); } } |
E:泛型高级通配符
?：任意类型，如果没有明确，那么就是Object以及任意的java类
? extends E
：向下限定，E及其子类
? super E
：向上限定，E及其父类
|
import java.util.ArrayList; import java.util.Collection;
/* * 泛型高级(通配符) * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了 * ? extends E:向下限定，E及其子类 * ? super E:向上限定，E及其父类 */ class GenericDemo { public static void main(String[] args) { // 泛型如果明确的写的时候，前后必须一致 Collection<Object> c1 = new ArrayList<Object>(); // Collection<Object> c2 = new ArrayList<Animal>(); // Collection<Object> c3 = new ArrayList<Dog>(); // Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的类型都是可以的 Collection<?> c5 = new ArrayList<Object>(); Collection<?> c6 = new ArrayList<Animal>(); Collection<?> c7 = new ArrayList<Dog>(); Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子类 //Collection<? extends Animal> c9 = new ArrayList<Object>();//它不行，编译报错 Collection<? extends Animal> c10 = new ArrayList<Animal>(); Collection<? extends Animal> c11 = new ArrayList<Dog>(); Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E极其父类 Collection<? super Animal> c13 = new ArrayList<Object>(); Collection<? super Animal> c14 = new ArrayList<Animal>(); // Collection<? super Animal> c15 = new ArrayList<Dog>();//它不行，编译报错 // Collection<? super Animal> c16 = new ArrayList<Cat>();//它不行，编译报错 } }
class Animal { }
class Dog extends Animal { }
class Cat extends Animal { } |
F:案例
1集合存储自定义对象，遍历，要求使用泛型
|
import java.util.ArrayList; import java.util.Iterator;
/* * 需求：存储自定义对象并遍历。 * * A:创建学生类 * B:创建集合对象 * C:创建元素对象 * D:把元素添加到集合 * E:遍历集合 */ class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 // JDK7的新特性：泛型推断。 // 但是我不建议这样使用。 // ArrayList<Student> array = new ArrayList<>();
ArrayList<Student> array = new ArrayList<Student>();
// 创建元素对象 Student s1 = new Student("曹操", 40); // 后知后觉 Student s2 = new Student("蒋干", 30); // 不知不觉 Student s3 = new Student("诸葛亮", 26);// 先知先觉
// 添加元素 array.add(s1); array.add(s2); array.add(s3);
// 遍历 Iterator<Student> it = array.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("------------------");
for (int x = 0; x < array.size(); x++) { Student s = array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } } |
(6)泛型的应用场景
一般是在集合中使用。
|
import java.util.ArrayList; import java.util.Iterator;
/* * 泛型在哪些地方使用呢? * 看API，如果类，接口，抽象类后面跟的有<E>就说要使用泛型。 一般来说就是在集合中使用。 */ class ArrayListDemo { public static void main(String[] args) { // 用ArrayList存储字符串元素，并遍历。用泛型改进代码 ArrayList<String> array = new ArrayList<String>();
array.add("hello"); array.add("world"); array.add("java");
Iterator<String> it = array.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s); } System.out.println("-----------------");
for (int x = 0; x < array.size(); x++) { String s = array.get(x); System.out.println(s); } } } |
3:增强for循环(掌握)
(1)是for循环的一种
(2)格式：
for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
使用该变量即可，该变量其实就是数组或者集合中的元素。
}
(3)好处：
简化了数组和集合的遍历
(4)弊端
增强for循环的目标不能为null。建议在使用前，先判断是否为null。
(5)增强for代码演示
|
import java.util.ArrayList; import java.util.List;
/* * JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举 * * 增强for:是for循环的一种。 * * 格式： * for(元素数据类型 变量 : 数组或者Collection集合) { * 使用变量即可，该变量就是元素 * } * * 好处：简化了数组和集合的遍历。 * * 弊端： 增强for的目标不能为null。 * 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。 */ class ForDemo { public static void main(String[] args) { // 定义一个int数组 int[] arr = { 1, 2, 3, 4, 5 }; for (int x = 0; x < arr.length; x++) { System.out.println(arr[x]); } System.out.println("---------------"); // 增强for for (int x : arr) { System.out.println(x); } System.out.println("---------------"); // 定义一个字符串数组 String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" }; // 增强for for (String s : strArray) { System.out.println(s); } System.out.println("---------------"); // 定义一个集合 ArrayList<String> array = new ArrayList<String>(); array.add("hello"); array.add("world"); array.add("java"); // 增强for for (String s : array) { System.out.println(s); } System.out.println("---------------");
List<String> list = null; // NullPointerException // 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断 // 说白了，这就是迭代器的功能 if (list != null) { for (String s : list) { System.out.println(s); } }
// 增强for其实是用来替代迭代器的 //ConcurrentModificationException // for (String s : array) { // if ("world".equals(s)) { // array.add("javaee"); // } // } // System.out.println("array:" + array); } } |
4:静态导入(了解)
(1)可以导入到方法级别的导入
(2)格式：
import static 包名....类名.方法名;
(3)注意事项：
A:方法必须是静态的
B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
所以一般我们并不使用静态导入，但是一定要能够看懂。
|
/* * 静态导入： * 格式：import static 包名….类名.方法名; * 可以直接导入到方法的级别 * * 静态导入的注意事项： * A:方法必须是静态的 * B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。 由此可见，意义不大，所以一般不用，但是要能看懂。 */ import static java.lang.Math.abs; import static java.lang.Math.pow; import static java.lang.Math.max;
//错误 //import static java.util.ArrayList.add;
class StaticImportDemo { public static void main(String[] args) { // System.out.println(java.lang.Math.abs(-100)); // System.out.println(java.lang.Math.pow(2, 3)); // System.out.println(java.lang.Math.max(20, 30)); // 太复杂，我们就引入到import
// System.out.println(Math.abs(-100)); // System.out.println(Math.pow(2, 3)); // System.out.println(Math.max(20, 30)); // 太复杂，有更简单
// System.out.println(abs(-100)); System.out.println(java.lang.Math.abs(-100)); System.out.println(pow(2, 3)); System.out.println(max(20, 30)); }
public static void abs(String s){ System.out.println(s); } } |
5:可变参数(掌握)
(1)应用场景
如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2)格式
修饰符 返回值类型 方法名(数据类型... 变量) {}
注意：
A:该变量其实是一个数组名
B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法
asList()把数组转成集合。
注意：这个集合的长度不能改变。
|
import java.util.Arrays; import java.util.List;
/* * 把数组转化成集合，转化之后的集合的长度不能改变。 * public static <T> List<T> asList(T... a):把数组转成集合 * * 注意事项： * 虽然可以把数组转成集合，但是集合的长度不能改变。 */ class ArraysDemo { public static void main(String[] args) { // 定义一个数组 // String[] strArray = { "hello", "world", "java" }; // List<String> list = Arrays.asList(strArray);
List<String> list = Arrays.asList("hello", "world", "java");
//不支持增加和删除，但可以修改 // list.add("javaee");// UnsupportedOperationException // list.remove(1);// UnsupportedOperationException list.set(1, "javaee");
for (String s : list) { System.out.println(s); } } } |
(4)代码演示
|
/* * 可变参数：定义方法的时候不知道该定义多少个参数 * 格式： * 修饰符 * * } * * 注意： * 这里的变量其实是一个数组 * 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个 */ class ArgsDemo { public static void main(String[] args) { // 2个数据求和 int a = 10; int b = 20; int result = sum(a, b); System.out.println("result:" + result);
// 3个数据的求和 int c = 30; result = sum(a, b, c); System.out.println("result:" + result);
// 4个数据的求和 int d = 30; result = sum(a, b, c, d); System.out.println("result:" + result);
// 需求：我要写一个求和的功能，到底是几个数据求和呢， //我不太清楚，但是我知道在调用的时候我肯定就知道了 // 为了解决这个问题，Java就提供了一个东西：可变参数 result = sum(a, b, c, d, 40); System.out.println("result:" + result);
result = sum(a, b, c, d, 40, 50); System.out.println("result:" + result); }
public static int sum(int... a) { // System.out.println(a); //return 0;
int s = 0;
for(int x : a){ s +=x; }
return s; }
// public static int sum(int a, int b, int c, int d) { // return a + b + c + d; // } // // public static int sum(int a, int b, int c) { // return a + b + c; // } // // public static int sum(int a, int b) { // return a + b; // } } |
6:练习(掌握)
A:集合的嵌套遍历
|
import java.util.ArrayList;
/* * 集合的嵌套遍历 * 需求： * 我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student> * 但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。 * 而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢? * 就是这个样子的：ArrayList<ArrayList<Student>> */ class ArrayListDemo { public static void main(String[] args) { // 创建大集合 ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();
// 创建第一个班级的学生集合 ArrayList<Student> firstArrayList = new ArrayList<Student>(); // 创建学生 Student s1 = new Student("唐僧", 30); Student s2 = new Student("孙悟空", 29); Student s3 = new Student("猪八戒", 28); Student s4 = new Student("沙僧", 27); Student s5 = new Student("白龙马", 26); // 学生进班 firstArrayList.add(s1); firstArrayList.add(s2); firstArrayList.add(s3); firstArrayList.add(s4); firstArrayList.add(s5); // 把第一个班级存储到学生系统中 bigArrayList.add(firstArrayList);
// 创建第二个班级的学生集合 ArrayList<Student> secondArrayList = new ArrayList<Student>(); // 创建学生 Student s11 = new Student("诸葛亮", 30); Student s22 = new Student("司马懿", 28); Student s33 = new Student("周瑜", 26); // 学生进班 secondArrayList.add(s11); secondArrayList.add(s22); secondArrayList.add(s33); // 把第二个班级存储到学生系统中 bigArrayList.add(secondArrayList);
// 创建第三个班级的学生集合 ArrayList<Student> thirdArrayList = new ArrayList<Student>(); // 创建学生 Student s111 = new Student("宋江", 40); Student s222 = new Student("吴用", 35); Student s333 = new Student("高俅", 30); Student s444 = new Student("李师师", 22); // 学生进班 thirdArrayList.add(s111); thirdArrayList.add(s222); thirdArrayList.add(s333); thirdArrayList.add(s444); // 把第三个班级存储到学生系统中 bigArrayList.add(thirdArrayList);
// 遍历集合 for (ArrayList<Student> array : bigArrayList) { for (Student s : array) { System.out.println(s.getName() + "---" + s.getAge()); } } } } |
B:产生10个1-20之间的随机数，要求随机数不能重复
|
import java.util.ArrayList; import java.util.Random;
/* 个1-20之间的随机数，要求不能重复 * * 用数组实现，但是数组的长度是固定的，长度不好确定。 * 所以我们使用集合实现。 * * 分析： * A:创建产生随机数的对象 * B:创建一个存储随机数的集合。 开始。 * 是:先产生一个随机数，判断该随机数在集合中是否存在。 * 如果不存在:就添加，统计变量++。 * 如果存在:就不搭理它。 * 否：不搭理它 * E:遍历集合 */ class RandomDemo { public static void main(String[] args) { // 创建产生随机数的对象 Random r = new Random();
// 创建一个存储随机数的集合。 ArrayList<Integer> array = new ArrayList<Integer>();
开始。 int count = 0;
while (count < 10) { //先产生一个随机数 int number = r.nextInt(20) + 1;
//判断该随机数在集合中是否存在。 if(!array.contains(number)){ //如果不存在:就添加，统计变量++。 array.add(number); count++; } }
//遍历集合 for(Integer i : array){ System.out.println(i); } } } |
C:键盘录入多个数据，以0结束，并在控制台输出最大值
|
import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner;
/* 结束，要求在控制台输出这多个数据中的最大值 * * 分析： * A:创建键盘录入数据对象 * B:键盘录入多个数据,我们不知道多少个，所以用集合存储 结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了 * D:把集合转成数组 * E:对数组排序 * F:获取该数组中的最大索引的值 */ class ArrayListDemo { public static void main(String[] args) { // 创建键盘录入数据对象 Scanner sc = new Scanner(System.in);
// 键盘录入多个数据,我们不知道多少个，所以用集合存储 ArrayList<Integer> array = new ArrayList<Integer>();
结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了 while (true) { System.out.println("请输入数据："); int number = sc.nextInt(); if (number != 0) { array.add(number); } else { break; } }
// 把集合转成数组 // public <T> T[] toArray(T[] a) Integer[] i = new Integer[array.size()]; // Integer[] ii = array.toArray(i); array.toArray(i); // System.out.println(i); // System.out.println(ii);
// 对数组排序 // public static void sort(Object[] a) Arrays.sort(i);
// 获取该数组中的最大索引的值 System.out.println("数组是：" + arrayToString(i) + "最大值是:" + i[i.length - 1]); }
public static String arrayToString(Integer[] i) { StringBuilder sb = new StringBuilder();
sb.append("["); for (int x = 0; x < i.length; x++) { if (x == i.length - 1) { sb.append(i[x]); } else { sb.append(i[x]).append(", "); } } sb.append("]");
return sb.toString(); } } |
7:要掌握的代码
集合存储元素，加入泛型，并可以使用增强for遍历。
javaSE第十六天的更多相关文章
- javaSE第二十六天
第二十六天 414 1:网络编程(理解) 414 (1)网络编程:用Java语言实现计算机间数据的信息传递和资源共享 414 (2)网络编程模型 414 (3)网络编程的三要素 ...
- 第三百五十六天 how can I 坚持
一年了,三百五十六天.写个算法算下对不对. 今天突然想买辆自行车了.云马智行车,还是捷安特,好想买一辆. 网好卡.貌似少记了一天呢,357了.好快. 睡觉了,还没锻炼呢,太晚了. 1458748800 ...
- IT第二十六天 - Swing、上周总结
IT第二十六天 上午 Swing 1.对于方法的参数如果是int数值类型,应该直接调用该类中的常量属性,而不应该直接填入数字 2.Toolkit类中定义的方法是可以直接访问本地计算机(操作系统)信息的 ...
- Python第二十六天 python装饰器
Python第二十六天 python装饰器 装饰器Python 2.4 开始提供了装饰器( decorator ),装饰器作为修改函数的一种便捷方式,为工程师编写程序提供了便利性和灵活性装饰器本质上就 ...
- OCM_第十六天课程：Section7 —》GI 及 ASM 安装配置 _安装 GRID 软件/创建和管理 ASM 磁盘组/创建和管理 ASM 实例
注:本文为原著(其内容来自 腾科教育培训课堂).阅读本文注意事项如下: 1:所有文章的转载请标注本文出处. 2:本文非本人不得用于商业用途.违者将承当相应法律责任. 3:该系列文章目录列表: 一:&l ...
- 孤荷凌寒自学python第八十六天对selenium模块进行较详细的了解
孤荷凌寒自学python第八十六天对selenium模块进行较详细的了解 (今天由于文中所阐述的原因没有进行屏幕录屏,见谅) 为了能够使用selenium模块进行真正的操作,今天主要大范围搜索资料进行 ...
- 孤荷凌寒自学python第七十六天开始写Python的第一个爬虫6
孤荷凌寒自学python第七十六天开始写Python的第一个爬虫6 (完整学习过程屏幕记录视频地址在文末) 今天在上一天的基础上继续完成对我的第一个代码程序的书写. 不过由于对python-docx模 ...
- 孤荷凌寒自学python第六十六天学习mongoDB的基本操作并进行简单封装5
孤荷凌寒自学python第六十六天学习mongoDB的基本操作并进行简单封装5并学习权限设置 (完整学习过程屏幕记录视频地址在文末) 今天是学习mongoDB数据库的第十二天. 今天继续学习mongo ...
- 孤荷凌寒自学python第五十六天通过compass客户端和mongodb shell 命令来连接远端MongoDb数据库
孤荷凌寒自学python第五十六天通过compass客户端和mongodb shell 命令来连接远端MongoDb数据库 (完整学习过程屏幕记录视频地址在文末) 今天是学习mongoDB数据库的第二 ...
随机推荐
- 获取mysql数据表中的列名
select COLUMN_NAME from information_schema.columns where table_name='table_name' DESCRIBE table_name ...
- Mac 10.10下安装MySQL5.6.21提示安装失败
只要要在安装的第三步在自定里不要选Startup item就可以了
- 20145305 《Java程序设计》第8周学习总结
教材学习内容总结 1.NIO使用频道来衔接数据节点,可以设定缓冲区容量,在缓冲区中对感兴趣的数据区块进行标记,提供clear().rewind().flip().compact()等高级操作 2.想要 ...
- C++学习16 继承时的名字遮蔽
如果派生类中的成员变量和基类中的成员变量重名,那么就会遮蔽从基类继承过来的成员变量.所谓遮蔽,就是使用新增的成员变量,而不使用继承来的. 成员函数也一样,如果函数名和参数签名都相同,就会造成遮蔽.如果 ...
- 不能使用 snapshot 的解决方式
http://www.mzone.cc/article/654.html 有两种方法可以解决: 1.第一种方法是在项目的pom文件中进行配置,如下: <repositories> < ...
- 微信用户授权，取openid
var appid = "wxb5f2540cff5c72be"; var secret = "3de016d0c294b82a5c74ce3fc4865271" ...
- HDU 5808[数位dp]
/* 题意: 给你l和r,范围9e18,求l到r闭区间有多少个数字满足,连续的奇数的个数都为偶数,连续的偶数的个数都为奇数. 例如33433符合要求,44不符合要求.不能含有前导零. 思路: 队友说是 ...
- webform中的Eval的使用
<strong>.在前台html控件调用c#后台变量.</strong> 在后台的类代码里定义一个字符串.如 public partial class Index : Syst ...
- Java: 基类、子类、构造函数、程序块的初始化顺序
初始化顺序 基类static block 子类static block 基类non-static block 子类non-static block 基类constructor 子类constructo ...
- Metrics.NET report to Zabbix
废话不多说,先上git地址 https://github.com/binking338/Metrics.Reporters.ZabbixReporter 实现了Metrics.NET到Zabbix的报 ...