day16-----------集合框架
ArrayList存储java
package cn.itcast_01;
import java.util.ArrayList;
import java.util.Iterator;
/*
* List的子类特色：
* ArrayList:
* 底层数据结构是数组，查询快，增删慢
* 线程不安全，效率高
* Vector:
* 底层数据结构是数组，查询快，增删慢
* 线程安全，效率低
* LinkedList:
* 底层数据结构是链表，查询慢，增删快
* 线程不安全，效率高
*
* 案例：
* 使用List的任何子类存储字符串或者存储自定义对象并遍历。
*
* ArrayList的使用。
* 存储字符串并遍历
*/
public 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);
}
}
}
Vector的特有功能：
android
package cn.itcast_02;
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:简化书写
*/
public 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);
}
}
}
Linkedlist的特有功能
数组
package cn.itcast_03;
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()
*/
public 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);
}
}
去除ArrayList集合中的重复字符串元素
安全
package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
* ArrayList去除集合中字符串的重复值(字符串的内容相同)
*
* 分析：
* A:建立集合对象
* B:添加多个字符串元素(包含内容相同的)
* C:建立新集合
* D:遍历旧集合,获取获得每个元素
* E:拿这个元素到新集合去找，看有没有
* 有：不搭理它
* 没有：就添加到新集合
* F:遍历新集合
*/
public 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);
}
}
}
去除ArrayList集合中的重复字符串元素案例2
数据结构
package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 要求：不能建立新的集合，就在之前的集合上作。
*/
public 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");
// 由选择排序思想引入，咱们就能够经过这种思想作这个题目
// 拿0索引的依次和后面的比较，有就把后的干掉
// 同理，拿1索引...
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);
}
}
}
去除ArrayList集合中的重复自定义对象元素案例
app
package cn.itcast_04;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
*
* 咱们按照和字符串同样的操做，发现出问题了。
* 为何呢?
* 咱们必须思考哪里会出问题?
* 经过简单的分析，咱们知道问题出如今了判断上。
* 而这个判断功能是集合本身提供的，因此咱们若是想很清楚的知道它是如何判断的，就应该去看源码。
* contains()方法的底层依赖的是equals()方法。
* 而咱们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
* Object()的equals()默认比较的是地址值，因此，它们进去了。由于new的东西，地址值都不一样。
* 按照咱们本身的需求，比较成员变量的值，重写equals()便可。
* 自动生成便可。
*/
public class ArrayListDemo3 {
public static void main(String[] args) {
// 建立集合对象
ArrayList array = new ArrayList();
// 建立学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("林志玲", 40);
Student s3 = new Student("凤姐", 35);
Student s4 = new Student("芙蓉姐姐", 18);
Student s5 = new Student("翠花", 16);
Student s6 = new Student("林青霞", 27);
Student s7 = new Student("林青霞", 18);
// 添加元素
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5);
array.add(s6);
array.add(s7);
// 建立新集合
ArrayList newArray = new ArrayList();
// 遍历旧集合,获取获得每个元素
Iterator it = array.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
// 拿这个元素到新集合去找，看有没有
if (!newArray.contains(s)) {
newArray.add(s);
}
}
// 遍历新集合
for (int x = 0; x < newArray.size(); x++) {
Student s = (Student) newArray.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
用LinkedList模拟栈数据结构的集合并测试案例
dom
package cn.itcast_05;
import java.util.LinkedList;
/**
* 自定义的栈集合
*
* @author 风清扬
* @version V1.0
*/
public 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();
}
}
package cn.itcast_05;
/*
* MyStack的测试
*/
public 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());
}
}
}
ArrayList存储自定义对象并遍历泛型
ide
package cn.itcast_02;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 需求：存储自定义对象并遍历。
*
* A:建立学生类
* B:建立集合对象
* C:建立元素对象
* D:把元素添加到集合
* E:遍历集合
*/
public 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());
}
}
}
经过Object转型问题引入泛型
工具
package cn.itcast_03;
public class ObjectTool {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) { // Object obj = new Integer(30);
this.obj = obj;
}
}
package cn.itcast_03;
/*
* 早期的时候，咱们使用Object来表明任意的类型。
* 向上转型是没有任何问题的，可是在向下转型的时候其实隐含了类型转换的问题。
* 也就是说这样的程序其实并非安全的。因此Java在JDK5后引入了泛型，提升程序的安全性。
*/
public class ObjectToolDemo {
public static void main(String[] args) {
ObjectTool ot = new ObjectTool();
// 正常使用
ot.setObj(new Integer(27));
Integer i = (Integer) ot.getObj();
System.out.println("年龄是：" + i);
ot.setObj(new String("林青霞"));
String s = (String) ot.getObj();
System.out.println("姓名是：" + s);
System.out.println("---------");
ot.setObj(new Integer(30));
// ClassCastException
String ss = (String) ot.getObj();
System.out.println("姓名是：" + ss);
}
}
泛型方法（一）
测试
package arraylist;
public class GenericDemo<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
package arraylist;
public class GenericTest {
public static void main(String[] args) {
GenericDemo<String> gd = new GenericDemo<String>();
gd.setObj("zhangsan");
System.out.println("name:"+gd.getObj());
}
}
泛型方法（二）
package arraylist;
public class GenericDemo<T> {
public void show(T t){
System.out.println(t);
}
}
package arraylist;
public class GenericTest {
public static void main(String[] args) {
GenericDemo<String> gd = new GenericDemo<String>();
System.out.print("name:");
gd.show("lisi");
}
}
泛型方法（把泛型定义在方法上）
package arraylist;
public class GenericDemo<T> {
public <T> void show(T t){
System.out.println(t);
}
}
package arraylist;
public class GenericTest {
public static void main(String[] args) {
GenericDemo gd = new GenericDemo();
gd.show("lisi");
gd.show(20);
gd.show(true);
}
}
泛型接口的概述和使用
package cn.itcast_06;
/*
* 泛型接口：把泛型定义在接口上
*/
public interface Inter<T> {
public abstract void show(T t);
}
package cn.itcast_06;
//实现类在实现接口的时候
//第一种状况：已经知道该是什么类型的了
//public class InterImpl implements Inter<String> {
//
// @Override
// public void show(String t) {
// System.out.println(t);
// }
// }
//第二种状况：还不知道是什么类型的
public class InterImpl<T> implements Inter<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
package cn.itcast_06;
public 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);
}
}
泛型高级之通配符
package cn.itcast_07;
import java.util.ArrayList;
import java.util.Collection;
/*
* 泛型高级(通配符)
* ?:任意类型，若是没有明确，那么就是Object以及任意的Java类了
* ? extends E:向下限定，E及其子类
* ? super E:向上限定，E极其父类
*/
public 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 {
}
加强for的概述和使用
package cn.itcast_01;
import java.util.ArrayList;
import java.util.List;
/*
* JDK5的新特性：自动拆装箱,泛型,加强for,静态导入,可变参数,枚举
*
* 加强for:是for循环的一种。
*
* 格式：
* for(元素数据类型 变量 : 数组或者Collection集合) {
* 使用变量便可，该变量就是元素
* }
*
* 好处：简化了数组和集合的遍历。
*
* 弊端： 加强for的目标不能为null。
* 如何解决呢?对加强for的目标先进行不为null的判断，而后在使用。
*/
public 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);
}
}
静态导入的概述和使用
package cn.itcast_02;
/*
* 静态导入：
* 格式：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;
public 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);
}
}
可变参数的概述和使用
package cn.itcast_03;
/*
* 可变参数：定义方法的时候不知道该定义多少个参数
* 格式：
* 修饰符 返回值类型 方法名(数据类型… 变量名){
*
* }
*
* 注意：
* 这里的变量实际上是一个数组
* 若是一个方法有可变参数，而且有多个参数，那么，可变参数确定是最后一个
*/
public 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;
// }
}
Arrays工具类的asList()方法的使用
package cn.itcast_03;
import java.util.Arrays;
import java.util.List;
/*
* public static <T> List<T> asList(T... a):把数组转成集合
*
* 注意事项：
* 虽然能够把数组转成集合，可是集合的长度不能改变。
*/
public 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");
// UnsupportedOperationException
// list.add("javaee");
// UnsupportedOperationException
// list.remove(1);
list.set(1, "javaee");
for (String s : list) {
System.out.println(s);
}
}
}
集合嵌套存储和遍历元素的案例图解
集合嵌套存储和遍历元素的案例代码实现
package cn.itcast_01;
import java.util.ArrayList;
/*
* 集合的嵌套遍历
* 需求：
* 咱们班有学生，每个学生是否是一个对象。因此咱们可使用一个集合表示咱们班级的学生。ArrayList<Student>
* 可是呢，咱们旁边是否是还有班级，每一个班级是否是也是一个ArrayList<Student>。
* 而我如今有多个ArrayList<Student>。也要用集合存储，怎么办呢?
* 就是这个样子的：ArrayList<ArrayList<Student>>
*/
public 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());
}
}
}
}
产生10个1-20之间的随机数要求随机数不能重复案例
package cn.itcast_02;
import java.util.ArrayList;
import java.util.Random;
/*
* 获取10个1-20之间的随机数，要求不能重复
*
* 用数组实现，可是数组的长度是固定的，长度很差肯定。
* 因此咱们使用集合实现。
*
* 分析：
* A:建立产生随机数的对象
* B:建立一个存储随机数的集合。
* C:定义一个统计变量。从0开始。
* D:判断统计遍历是否小于10
* 是:先产生一个随机数，判断该随机数在集合中是否存在。
* 若是不存在:就添加，统计变量++。
* 若是存在:就不搭理它。
* 否：不搭理它
* E:遍历集合
*/
public class RandomDemo {
public static void main(String[] args) {
// 建立产生随机数的对象
Random r = new Random();
// 建立一个存储随机数的集合。
ArrayList<Integer> array = new ArrayList<Integer>();
// 定义一个统计变量。从0开始。
int count = 0;
// 判断统计遍历是否小于10
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);
}
}
}
键盘录入多个数据在控制台输出最大值案例
package cn.itcast_03;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
* 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
*
* 分析：
* A:建立键盘录入数据对象
* B:键盘录入多个数据,咱们不知道多少个，因此用集合存储
* C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
* D:把集合转成数组
* E:对数组排序
* F:获取该数组中的最大索引的值
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 建立键盘录入数据对象
Scanner sc = new Scanner(System.in);
// 键盘录入多个数据,咱们不知道多少个，因此用集合存储
ArrayList<Integer> array = new ArrayList<Integer>();
// 以0结束,这个简单，只要键盘录入的数据是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();
}
}
相关文章
- 1. day16<集合框架+>
- 2. Day16 HTML 框架集
- 3. 【JAVA集合框架】Java集合框架
- 4. day16-django框架初识
- 5. Java集合—集合框架
- 6. 集合_java集合框架
- 7. 集合框架
- 8. 框架——集合
- 9. 框架集合
- 10. Java集合框架
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • ☆技术问答集锦（13）Java Instrument原理
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. day16<集合框架+>
- 2. Day16 HTML 框架集
- 3. 【JAVA集合框架】Java集合框架
- 4. day16-django框架初识
- 5. Java集合—集合框架
- 6. 集合_java集合框架
- 7. 集合框架
- 8. 框架——集合
- 9. 框架集合
- 10. Java集合框架