关于接口ArrayList，HashSet，HashMap

泛型容器类：实现缓存数组不太行，要不停的加，数组会满，所以使用容器

package Notebook;
import java.util.*;

public class Notebook {
	private ArrayList<String> notes=new ArrayList<String>();
	//ArrayList是引入类，<String>这是用来存放String的一个List
	//这就叫泛型类，这种泛型类是一种容器
	//notes本身是对象管理者
public void add(String s) {
	
}
public int getSize() {
	return 0;
}
public String getNote(int index) {
	return " ";
}
public boolean removeNote(int index) {
	return true;
}
//public void list() {
	
//}
public String[] list() {
	return new String[10];
}//以数组的形式返回
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

容器类用于存放对象
容器类有两个类型：
1、容器的类型ArrayList
2、元素的类型String在尖括号里

public class Notebook {
	private ArrayList<String> notes=new ArrayList<String>();
	//ArrayList是引入类，<String>这是用来存放String的一个List
	//这就叫泛型类，这种泛型类是一种容器
	//notes本身是对象管理者
	private int size=0;
public void add(String s) {
	notes.add(s);//ArrayList里自带的函数
	//notes.add(10);The method add(int, String) in the type ArrayList<String> is not applicable for the 
	// arguments (int)会报错
	size++;//这样做可以计数，但是ArrayList自带计数函数
}
public int getSize() {
	return size;
}

package Notebook;
import java.util.*;

public class Notebook {
	private ArrayList<String> notes=new ArrayList<String>();
	//ArrayList是引入类，<String>这是用来存放String的一个List
	//这就叫泛型类，这种泛型类是一种容器
	//notes本身是对象管理者
	private int size=0;
public void add(String s) {
	notes.add(s);//ArrayList里自带的函数
	//notes.add(10);The method add(int, String) in the type ArrayList<String> is not applicable for the 
	// arguments (int)会报错
}
public int getSize() {
	return notes.size();//ArrayList自己知道自己里面有多少东西
}
public String getNote(int index) {
	return " ";
}
public boolean removeNote(int index) {
	return true;
}
//public void list() {
	
//}
public String[] list() {
	return new String[10];
}//以数组的形式返回
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

package Notebook;
import java.util.*;

public class Notebook {
	private ArrayList<String> notes=new ArrayList<String>();
	//ArrayList是引入类，<String>这是用来存放String的一个List
	//这就叫泛型类，这种泛型类是一种容器
	//notes本身是对象管理者
	private int size=0;
public void add(String s) {
	notes.add(s);//ArrayList里自带的函数
	//notes.add(10);The method add(int, String) in the type ArrayList<String> is not applicable for the 
	// arguments (int)会报错
}
public int getSize() {
	return notes.size();//ArrayList自己知道自己里面有多少东西
}
public String getNote(int index) {
	return " ";
}
public boolean removeNote(int index) {
	return true;
}
//public void list() {
	
//}
public String[] list() {
	return new String[10];
}//以数组的形式返回
	public static void main(String[] args) {
		String[] a=new String[2];
		a[0]="first";
		a[1]="second";
		Notebook nb=new Notebook();
        nb.add("first");
        nb.add("second");
        System.out.println(nb.getSize());
	}

}

ArrayList会保存加入元素顺序，形成下标索引，类似于数组，用于获取其中元素

public String getNote(int index) {
	return notes.get(index);//返回该下标元素
}
//System.out.println(nb.getNote(0));

输出时要注意下标不要越界
指定坐标添加元素

public void add(String s,int location) {
	notes.add(location, s);//指定坐标添加元素
}
 System.out.println(nb.getNote(1));

移除某个元素

public void removeNote(int index) {//因此这里就不需要返回是否成功删除了，把boolean改成void
	 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;
}
String[] a=nb.list();
        for(String s:a) {
        	System.out.println(a);
        }

对象数组里每个元素都是对象的管理者而非对象本身
在对对象数组进行foreach循环时
对象数组可以被改变，对于int数组来说是无法发生变化的，原因是对象数组管理的时对象的管理者，set（0）时是让b中所指的管理者对象变成了0

class Value{
	private int i;
	public void set(int i) {
		this.i=i;
	}
	public int get() {
		return i;
	}
}
public static void main(String[] args) {
		Value[] a=new Value[10];
		for(int i=0;i<a.length;i++) {
			a[i]=new Value();
			a[i].set(i);
		}
		for(Value b:a) {
			System.out.print(b.get());//0123456789
			b.set(0);
		}
		for(Value b:a) {
			System.out.print(b.get());//0000000000
		}
		public static void main(String[] args) {
		ArrayList<String> a=new ArrayList<String>();
		a.add("first");
		a.add("second");
		for(String s:a) {
			System.out.println(s);
		}

HashSet
这个set就是数学中的集合，具有互异性
并且不会记住顺序，集合具有无序性

HashSet<String> s=new HashSet<String>();
		s.add("first");
		s.add("second");
		s.add("first");
		for(String k:s) {
			System.out.println(k);
		}

public String toString（）；重写该函数能帮助程序在System.out.println时直接输出对象就可以了
Hash表

package Coin;
import java.util.*;
public class Coin {
	private HashMap<Integer,String> coinnames=new HashMap<Integer,String>();//key&&value
	//这里必须是Integer，这里所有类型必须是对象而不能是基本类型，包裹类型可以
	public Coin() {
		coinnames.put(1,"penny");
		coinnames.put(10,"dime");
		coinnames.put(25,"quarter");
		coinnames.put(50,"half-dollar");
	}
    public String getName(int amount) {
    	return coinnames.get(amount);
    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int amount=sc.nextInt();
		Coin c=new Coin();
		System.out.println(c.getName(amount));
	}
}

可以加以判断该key是否在map里有值

public String getName(int amount) {
    	if(coinnames.containsKey(amount))
    	return coinnames.get(amount);
    	else
    		return "not found";
    }

package Coin;
import java.util.*;
public class Coin {
	private HashMap<Integer,String> coinnames=new HashMap<Integer,String>();//key&&value
	//这里必须是Integer，这里所有类型必须是对象而不能是基本类型，包裹类型可以
	public Coin() {
		coinnames.put(1,"penny");
		coinnames.put(10,"dime");
		coinnames.put(25,"quarter");
		coinnames.put(50,"half-dollar");
		coinnames.put(50,"五毛");//会覆盖
		System.out.println(coinnames.keySet().size());//不会直接告诉你有几组，但是会形成keyset的一个集合，这个集合下面有size函数，可以表示有几组
		System.out.println(coinnames);
		for(Integer k:coinnames.keySet()) {//给出了关键词集合
		    String s=coinnames.get(k);
		    System.out.println(s);//Hash表的特殊遍历
		}
	}
    public String getName(int amount) {
    	if(coinnames.containsKey(amount))
    	return coinnames.get(amount);
    	else
    		return "not found";
    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int amount=sc.nextInt();
		Coin c=new Coin();
		System.out.println(c.getName(amount));
	}
}