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();
	}
}
相關文章
相關標籤/搜索