[系统运维]8_Java_对象容器

顺序容器

所谓容器，就是“放东西的东西”。数组可以看作是一种容器，但是数组的元素个数一旦确定就无法改变，这在实际使用中是很大的不足。一般意义上的容器，是指具有自动增长容量能力的存放数据的一种数据结构。在面向对象语言中，这种数据结构本身表达为一个对象。所以才有“放东西的东西”的说法。

Java具有丰富的容器，Java的容器具有丰富的功能和良好的性能。熟悉并能充分有效地利用好容器，是现代程序设计的基本能力。

我们首先学习的是顺序容器，即放进容器中的对象是按照指定的顺序（放的顺序）排列起来的，而且允许具有相同值的多个对象存在。

记事本

• 能存储记录
• 不限制能存储的记录的数量
• 能知道以及存储的记录的数量
• 能查看存进去的每一条记录
• 能删除一条记录
• 能列出所有的记录

接口设计

• add(String note);
• getSize();
• getNote(int index);
• removeNote(int index);
• list();

范型类 ArrayList<>

	private ArrayList<String> notes = new ArrayList<String>();
	// ArrayList<类型> 名称 = new ArrayList<类型>();

ArrayList<> 本身是一个类，而 notes 是对象管理者；容器类用来存放对象；
容器类有两个类型：

• 容器的类型；即这里的ArrayList
• 元素的类型；即这里的String

添加

添加 notes.add() 添加进去的时候是有顺序的 先添加进去的在前面；
获取大小 notes.getsizre()

package notebook;

import java.util.ArrayList;

public class NoteBook {
	private ArrayList<String> notes = new ArrayList<String>();
	public void add(String note)
	{
		notes.add(note);
	}
	public String getNote(int index)
	{
		return "";
	}
	public int getSize()
	{
		return notes.size();
	}
	public boolean removeNote(int index)
	{
		return true;
	}
	public String[] list()
	{
		return new String[10];
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NoteBook nb = new NoteBook();
		nb.add("first");
		nb.add("second");
		System.out.println(nb.getSize());// 2
	}

}

添加到指定下标的前面 notes.add(String note, int location)

package notebook;

import java.util.ArrayList;

public class NoteBook {
	private ArrayList<String> notes = new ArrayList<String>();
	public void add(String note)
	{
		notes.add(note);
	}
	public void add(String note, int location)
	{
		notes.add(location, note);
	}
	public String getNote(int index)
	{
		return notes.get(index);
	}
	public int getSize()
	{
		return notes.size();
	}
	public boolean removeNote(int index)
	{
		return true;
	}
	public String[] list()
	{
		return new String[10];
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NoteBook nb = new NoteBook();
		nb.add("first");
		nb.add("second");
		nb.add("thrild", 1);
		System.out.println(nb.getSize());// 2
		System.out.println(nb.getNote(1));
	}

}

删除 notes.remove(index)
列出所有 notes.list()

package notebook;

import java.util.ArrayList;

public class NoteBook {
	private ArrayList<String> notes = new ArrayList<String>();
	public void add(String note)
	{
		notes.add(note);
	}
	public void add(String note, int location)
	{
		notes.add(location, note);
	}
	public String getNote(int index)
	{
		return notes.get(index);
	}
	public int getSize()
	{
		return notes.size();
	}
	public void removeNote(int index)
	{
		notes.remove(index);
	}
	public String[] list()
	{
		String[] a = new String[notes.size()];
		notes.toArray(a); // 帮我们把数组填起来
//		for(int i = 0; i < notes.size(); i ++)
//		{
//			a[i] = notes.get(i);
//		}
		return a;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NoteBook nb = new NoteBook();
		nb.add("first");
		nb.add("second");
		nb.add("thrild", 1);
		System.out.println(nb.getSize());// 2
		System.out.println(nb.getNote(1));
		nb.removeNote(2);
		System.out.println(nb.getSize());
		String[] b = nb.list();
		for(String s : b)
		{
			System.out.println(s);
		}
	}

}

对象数组

当数组的元素的类型是类的时候，数组的每一个元素其实只是对象的管理者而不是对象本身。因此，仅仅创建数组并没有创建其中的每一个对象！

String[] a = new String[10];
System.out.println(a[0].length());

这个代码会报错，原因在于这个数组存放的是对象的管理者而不是对象本身；

package third;

public class Third {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[3];
		for(int i = 0; i < a.length; i ++)
		{
			a[i] = i;
		}
		for(int v : a)
		{
			System.out.println(v);
			v = 0;
		}
		for(int v : a)
		{
			System.out.println(v);
		}
	}
}

上面可以看到，用 for - each 是改不掉的；

package third;

class Value{
	private int i;
	public void set(int i)
	{
		this.i = i;
	}
	public int get()
	{
		return i;
	}
}
public class Third {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Value[] a = new Value[3];
		for(int i = 0; i < a.length; i ++)
		{
			a[i] = new Value();
			a[i].set(i);
		}
		for(Value v : a)
		{
			System.out.println(v.get());
			v.set(0);
		}
		for(Value v : a)
		{
			System.out.println(v.get());
		}
	}

}

而对象数组是可以改掉的，因为是多个管理者对应一个对象本身，通过管理者就可以找到本身；而单纯的数组，只是改的复制过来的值，本身并没有什么改变；

ArrayList<String> a = new ArrayList<String>();
// 也是可以使用 for - each 的

函数传递任意的参数

函数传递任意的参数，以及规定的最少的参数；

package notebook;

import java.util.ArrayList;

public class NoteBook {
	public static void fun(int num, int ...values)
	{
		//输出一个
		System.out.println(num);
		//输出任意个
		for(int s : values)
		{
			System.out.println(s);
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		fun(1, 2, 3);
	}

}
Varargs

集合容器

集合就是数学中的集合的概念：所有的元素都具有唯一的值，元素在其中没有顺序。
所谓的唯一是指输入的重复的当一个来处理；

ArrayList 重复的元素不会处理成一个

package notebook;

import java.util.ArrayList;

public class NoteBook {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> a = new ArrayList<String>();
		a.add("1");
		a.add("2");
		a.add("2");
		for(String s : a)
		{
			System.out.println(s);
		}
	}

}
/*
1
2
2
*/

HashSet 元素无序，重复的处理成一个

package notebook;

import java.util.HashSet;

public class NoteBook {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<String> a = new HashSet<String>();
		a.add("1");
		a.add("2");
		a.add("1");
		for(String s : a)
		{
			System.out.println(s);
		}
	}

}
/*
1
2
*/

package notebook;

import java.util.ArrayList;
import java.util.HashSet;

public class NoteBook {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<String> a = new HashSet<String>();
		a.add("2");
		a.add("1");
		a.add("1");
		System.out.println(a);
		ArrayList<String> b = new ArrayList<String>();
		b.add("2");
		b.add("1");
		b.add("1");
		System.out.println(b);
	}

}
/*
[1, 2]
[2, 1, 1]
*/

直接输出对象 toString 函数

package notebook;

import java.util.ArrayList;
import java.util.HashSet;

class Value{
	private int i;
	public void set(int i)
	{
		this.i = i;
	}
	public int get()
	{
		return i;
	}
	public String toString() {
		return "" + i;
	}
}
public class NoteBook {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Value v = new Value();
		v.set(10);
		System.out.println(v);
	}

}
// 10

散列表 Hash

private HashMap<Integer, String> a = new HashMap<Integer, String>();

同一个键 key 总是取最后一个键的元素；

package coins;

import java.util.HashMap;

public class Coin {
	private HashMap<Integer, String> a = new HashMap<Integer, String>();
	public Coin()
	{
		a.put(1, "DL1");
		a.put(2, "DL2");
		a.put(3, "DL3");
		a.put(3, "DL4");//重复的取最后一个
		System.out.println(a.keySet().size());
		System.out.println(a.keySet());
		System.out.println(a);
		for(Integer k : a.keySet())
		{
			String s = a.get(k);
			System.out.println(s);
		}
	}
	public String getName(int amount)
	{
		if(a.containsKey(amount))
		{
			return a.get(amount);
		}
		else
		{
			return "Not Found!!!";
		}
	}
	public String toString()
	{
		return a + "";
	}
	public static void main(String[] args) {
		Coin coin = new Coin();
		System.out.println(coin.getName(0));
		System.out.println(coin.getName(1));
		System.out.println(coin); //需要 toString() 函数
	}

}
/*
3
[1, 2, 3]
{1=DL1, 2=DL2, 3=DL4}
DL1
DL2
DL4
Not Found!!!
DL1
{1=DL1, 2=DL2, 3=DL4}
*/