package com.tiantian;
import java.util.*;
public class JAVAContainer {
public static void main(String[] args) throws Exception {
// ArrayList
{
ArrayList arraylist = new ArrayList();
arraylist.add(0, "end");//指定索引加入值
// 需注意的是，如果现有2个值，我加入索引为5的那么就会出现异常
for (int i = 0; i < 2; i++) {
arraylist.add(i, String.valueOf(i));
}
System.out.println("ArrayList:");
for (int i = 0; i < arraylist.size(); i++) {
System.out.print(arraylist.get(i) + ";");
}
arraylist.add("0");//直接加入值到ArrayList的最后
arraylist.add("0");
System.out.print(" ArrayList's lastIndexOf("0") is "
+ arraylist.lastIndexOf("0"));
}
// Arrays
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
System.out.println(" Arrays:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
System.out.print(" Arrays's length is " + array.length);//打印数组的长度
}
// Collections
{
String[] array = new String[] { "a", "b", "c" };
List list = Arrays.asList(array);
Collections.fill(list, "Fill");//用Fill填充全部元素
System.out.println(" Collections:");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ";");
}
array = new String[] { "1", "2", "3" };
List list2 = Arrays.asList(array);
Collections.copy(list, list2);//拷贝list2的数据进list
System.out.println(" " + list);
Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置
System.out.println(list);
}
// EventObject
{
String s = "hello";
String s2 = s;
EventObject eventobject = new EventObject(s);//一个准容器类型，确切的归类它不是容器
System.out.println("EventObject:");
System.out.println(eventobject.getSource());
System.out.println(eventobject.equals(s2));
}
// HashMap
{
HashMap hashmap = new HashMap();//一个速度最快的容器
hashmap.put("0", "c");
hashmap.put("1", "a");
hashmap.put("2", "b");
hashmap.put("3", "a");
System.out.println("HashMap:");
System.out.println(hashmap);//该容器有其内部的排序方式
Set set = hashmap.keySet();//获取全部键
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(hashmap.get(iterator.next()) + ";");
}
}
// HashSet
{
HashSet hashset = new HashSet();//一个绝对不能重复的类型
hashset.add("c");
hashset.add("b");
hashset.add("a");
hashset.add("a");
hashset.add("b");
System.out.println(" HashSet:");
System.out.println(hashset);
Iterator iterator = hashset.iterator();//取出元素
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// Hashtable
{
Hashtable hashtable = new Hashtable();//一个完全可以由其他容器替换的老容器类型
hashtable.put("0", "c");
hashtable.put("1", "a");
hashtable.put("3", "c");
hashtable.put("2", "b");
System.out.println(" Hashtable:");
Enumeration enumeration = hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品
while (enumeration.hasMoreElements()) {
System.out.print(enumeration.nextElement() + ";");
}
}
// IdentityHashMap
{
IdentityHashMap identityhashmap = new IdentityHashMap();
identityhashmap.put("0", "c");
identityhashmap.put("1", "a");
identityhashmap.put("3", "b");
identityhashmap.put("2", "a");
System.out.println(" IdentityHashMap:");
System.out.println(identityhashmap);
System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
System.out.println(identityhashmap.containsValue("a"));//是否包含值
Set set = identityhashmap.entrySet();//传为Set类型
System.out.println(set);
set = identityhashmap.keySet();//全部键
System.out.println(set);
}
// LinkedHashMap
{
LinkedHashMap linkedhashmap = new LinkedHashMap();
linkedhashmap.put("0", "b");
linkedhashmap.put("2", "a");
linkedhashmap.put("1", "c");
linkedhashmap.put("3", "b");
System.out.println("LinkedHashMap:");
System.out.println(linkedhashmap);
System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
System.out.println(linkedhashmap.containsValue("c"));//是否包含值
Set set = linkedhashmap.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(linkedhashmap.get(iterator.next()) + ";");
}
}
// LinkedHashSet
{
LinkedHashSet linkedhashset = new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
linkedhashset.add("c");
linkedhashset.add("a");
linkedhashset.add("a");
linkedhashset.add("b");
System.out.println(" LinkedHashSet:");
System.out.println(linkedhashset);
System.out.println(linkedhashset.contains("a"));//是否包含对象
Iterator iterator = linkedhashset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// LinkedList
{
LinkedList linkedlist = new LinkedList();//自由使用是它的特色
linkedlist.add("a");
linkedlist.add(1, "c");
linkedlist.addLast("b");
linkedlist.addFirst("d");
System.out.println(" LinkedList:");
System.out.println(linkedlist);
// linkedlist.clear();//该方法清空容器
// linkedlist.remove(0);//删除索引为0的元素
// linkedlist.remove("d");//删除值为d的元素
// linkedlist.removeFirst();//删除第一个元素
// linkedlist.removeLast();//删除最后一个元素
for (int i = 0; i < linkedlist.size(); i++) {
System.out.print(linkedlist.get(i) + ";");
}
}
// Stack
{
Stack stack = new Stack();//堆栈
stack.add("b");
stack.add(0, "c");
stack.push("d");
stack.add("e");
stack.push("a");
Enumeration enumeration = stack.elements();
System.out.println(" Stack:");
while (enumeration.hasMoreElements()) {
System.out.print(enumeration.nextElement() + ";");
}
// 后进先出
System.out.println(" " + stack.peek());
System.out.println(stack.pop());
System.out.println(stack.contains("d") + ";" + stack.contains("a"));//是否包含该元素,有趣的事情发生了
System.out.println(stack.search("c"));//非常有用的属性，检索，但是由后向前的排列
}
// TreeMap
{
TreeMap treemap = new TreeMap();
treemap.put("0", "d");
treemap.put("2", "a");
treemap.put("1", "b");
treemap.put("3", "c");
System.out.println(" TreeMap:");//可以对键排序
System.out.println(treemap);
System.out.println(treemap.firstKey());//返回第一个键
Set set = treemap.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(treemap.get(iterator.next()) + ";");
}
}
// TreeSet
{
TreeSet treeset = new TreeSet();//自动排序内容
treeset.add("b");
treeset.add("a");
treeset.add("c");
treeset.add("d");
System.out.println(" TreeSet:");
System.out.println(treeset);
System.out.println(treeset.first());//返回第一个元素
Iterator iterator = treeset.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
}
// Vector
{
Vector vector = new Vector();
vector.add(0, "b");
vector.add("a");
vector.addElement("d");
vector.add("c");
System.out.println(" Vector:");
System.out.println(vector);
vector.set(2, "h");//替换掉指定索引的元素
System.out.println(vector);
Object[] str = vector.toArray();
for (int i = 0; i < str.length; i++) {
System.out.print(str[i] + ";");
}
vector.setSize(2);//重新设置大小为2
System.out.println(" " + vector);
}
// WeakHashMap
{
WeakHashMap weakhashmap = new WeakHashMap();
weakhashmap.put("1", "b");
weakhashmap.put("2", "c");
weakhashmap.put("0", "d");
weakhashmap.put("3", "a");
System.out.println(" WeakHashMap:");
System.out.println(weakhashmap);
System.out.println(weakhashmap.containsKey("3"));//是否包含键
System.out.println(weakhashmap.containsValue("d"));//是否包含值
Set set = weakhashmap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ";");
}
// weakhashmap.remove("2");//删除该键对应的值
// weakhashmap.get("1");//获取指定键的值
}
}
}
JAVA提高认识Set集合之HashSet
java,jsp 2009-06-21 23:32 阅读225 评论0
字号： 大大 中中 小小
集合在Java里面的作用非凡，我们常用的有Set,List和Map三种，我们先熟悉一下Set，特别是HashSet的使用
package collection.lession2;
import java.util.HashSet;
import java.util.Set;
/**
* 老紫竹JAVA提高教程(2)-认识Set集合之HashSet。<br>
* Set用来保存不允许重复的数据。可以是任何对象类型。<br>
* JDK5以后，主类型可以通过autobox 放入Set里面。
*
* @author 老紫竹 JAVA世纪网(java2000.net)
*
*/
public class Lession2 {
public static void main(String[] args) {
// 普通测试
testNormal();
// 测试HashSet的特殊性
testForHashSet();
testForHashSet2();
}
/**
* 测试保存混合类型的数据.
*/
public static void testNormal() {
System.out.println("----- testNormal -----------");
// Set有多个实现，我们先看看最常用的HashSet
Set set = new HashSet();
// 添加一个字符串
set.add("字符串");
// 添加一个整数对象
set.add(new Integer(1));
// 利用JDK5的特性，增加一个浮点数
set.add(123.45);
// 我们看看集合里对象的数量
System.out.println(set.size());
// 我们尝试增加一个重复的字符串
set.add("字符串");
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 我们来测试看看是否集合里包含了某个数据
System.out.println(set.contains(123.45));
// 我们从里面把这个浮点数删除
set.remove(123.45);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
}
/**
* 专门针对HashSet的测试。
*/
public static void testForHashSet() {
System.out.println("----- testForHashSet -----------");
HashSet<MyObject> set = new HashSet<MyObject>();
// 增加一个null对象
set.add(null);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 再次增加一个null看看
set.add(null);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
MyObject obj = new MyObject("java2000", 2);
set.add(obj);
obj = new MyObject("csdn", 10);
set.add(obj);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 判断是否包含某个对象
System.out.println(set.contains(obj));
obj = new MyObject("java2000_net", 2);
set.add(obj);
// 我们再次看看集合里对象的数量
System.out.println(set.size());
// 我们尝试把obj再次放入set看看
// 并没有增加，因为是重复的
set.add(obj);
System.out.println(set.size());
// 我们构造一个新的对象，内容和前面的相同
obj = new MyObject("java2000_net", 2);
set.add(obj);
System.out.println(set.size());
// 我们修改一下obj里面的年龄，再看看
obj.setAge(3);
// 我们再测试看看是否包含此对象。
// 请注意，我们这个obj和前面的obj是同一个对象
&nbs-p; // 我们仅仅修改了一下我们的年龄
System.out.println(set.contains(obj));
// 我们尝试把obj再次放入set看看
// 我们又增加了长度
set.add(obj);
System.out.println(set.size());
}
/**
* 专门针对HashSet的测试2。
*/
public static void testForHashSet2() {
System.out.println("----- testForHashSet2 -----------");
HashSet<MyObject2> set = new HashSet<MyObject2>();
MyObject2 obj = null;
for (int i = 0; i < 3; i++) {
obj = new MyObject2("java2000" + i, i);
set.add(obj);
System.out.println(set.size());
}
}
}
class MyObject {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
MyObject(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) {
System.out.println("equals");
if (obj == null || !(obj instanceof MyObject)) {
return false;
}
MyObject o = (MyObject) obj;
return this.age == o.age && this.name.equals(o.name);
}
public int hashCode() {
int hashCode = name.hashCode() + String.valueOf(age).hashCode();
return hashCode;
}
}
class MyObject2 {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
MyObject2(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) {
System.out.println("equals");
if (obj == null || !(obj instanceof MyObject2)) {
return false;
}
MyObject2 o = (MyObject2) obj;
return this.age == o.age && this.name.equals(o.name);
}
pan class="keyword">int hashCode() {
return 1;
}
}
class MyObject3 {
private int age;
private String name;
// 采用一个变量进行控制
// 一旦生成了hashCode,则不再变动
private int HASHCODE = Integer.MIN_VALUE;
public int hashCode() {
if (HASHCODE == Integer.MIN_VALUE) {
// 重新生成本类的hashCode
HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
}
return HASHCODE;
}
}
说明,针对HashSet：
Set不允许重复
允许 null,重复的null只算一个
判断是否存在一个数据(是否重复)，先判断其hashCode是否存在，若存在再逐个判断hashCode相同的数据是否相等
判断是否相等，除了hashCode相等外，还要判断对象引用相等(==)，或者 equals
如果一个对象的hashCode变动了，会造成找不到这个对象，也就出现了内存泄漏的危险。
hashCode 方法是HashSet里面对象的关键，它的算法影响到了数据的分散和查找效率。某个确认对象的hashCode不应该变动，避免出现内存泄漏，可以采用如下方法，来方式属性变化造成hashCode变化
class MyObject3 {
private int age;
private String name;
// 采用一个变量进行控制
// 一旦生成了hashCode,则不再变动
private int HASHCODE = Integer.MIN_VALUE;
public int hashCode() {
if (HASHCODE == Integer.MIN_VALUE) {
// 重新生成本类的hashCode
HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
}
return HASHCODE;
}
}
文章出处：http://www.diybl.com/course/3_program/java/javajs/20081115/151023_3.html
Java集合List,Set,Map基础
2009-06-07 14:55
java中集合类位于java.util包下，与下面四个接口有关Collection,List,Set,Map接口。
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
Collection常用的方法：
boolean add(Object obj):向集合中加入Object对象，如果结合中已经存在该对象（注意这里的相同的对象是equals()返回的是true,既内容完全相同，而不是==）则直接返回false。
boolean contains(Object obj):集合中是否已经存在object对象，同时是指equals()方法比较对象返回true.
boolean remove(Object obj):从集合中移除Object对象。
void clear():清空集合。
int size():返回集合所包含的对象数目。
Object[] toArray():返回集合中全部对象的数组。
Object[] toArray(Object[] objs):把集合中的对象放入objs对象数组中，objs对象数组需要事先创建。
Set接口继承自Collection,但是不允许重复，继承了Collection的全部方法。
List接口继承自Collection，允许重复，并引入了位置下标的概念(这一点和数组有些相似)下标从0开始，List接口也称为列表，除继承了Collection的方法之外，还提供了一下常用的方法
Object set(int index,Object obj):将obj对象放置在列表下标index的位置，如果该位置上已经有对象，则替换并返回原对象。
Object get(int index):从列表中取出下标为index位置上的对象。
int indexOf(Object object):查找object对象在列表中的位置，如果找到返回第一次初夏的下标，如果没有找到，则返回-1
Map接口与Conllection接口没有任何关系，他用来存放键值对（key-value）常用的方法如下：
Object put(Object key,Object value):将键值对放入集合，如果键值对Key的值对在集合已经存在，则用value替换原来的值并返回原来对象。
Object get(Object key):返回Key键值对应的的值对象如果Key键值在集合中不存在则返回Null
int size():返回集合中键值对的数量。
boolean containsKey(Object key):判断集合中是否存在以key为键值的键值对。
boolean containsValue(Object value):判断集合中是否存在以value为值对象的键值对。
Object remove(Object key):从集合中移除键值为key的键值对。返回被移除的键值对象，如果集合中不存在以key为键值的键值对，则返回Null.
void clear():清空集合。
set KeySet():返回由所有键值组成的Set集合。
Collection values():返回有所有键值对象组成的Collection集合。
在这4个接口中我们常用的有Set,List，Map接口。以下是3种接口常见的实现类
Set : hashSet,TreeSet
List: ArrayList,LinkedList,Vector,Stack
Map: HashMap,TreeMap,Hashtable,Properties
下面具体示例
实例1
/**
*
*此程序演示ArrayList的常用方法
*/
import java.util.ArrayList;
import java.util.Random;
import java.util.Collections;
import java.util.List;
class PlayArrayList{
ArrayList array;
List lis;
public PlayArrayList(){
array=new ArrayList();
lis=new ArrayList();
}
public void add(){
for(int i=0;i<5;i++){
array.add(new Integer(i));
}
array.add("c");
array.add("sql");
array.add("jsp");
array.add("order");
array.add("linux");
array.add("java");
}
public void prinAll(){
add();
System.out.println("*****************************");
System.out.println("**从ArrayList中检索的对象********");
for(int i=0;i<array.size();i++){
System.out.println(array.get(i));
}
}
public void IndexPrin(){
System.out.println("**********************************************");
System.out.println("检索一个对象并返回第一个和最后一个位置");
System.out.println("java第一个位置="+array.indexOf("java"));
System.out.println("java最后位置="+array.lastIndexOf("java"));
System.out.println("**********************************************");
System.out.println("从已知列表中提取一个子列表");
lis=array.subList(5,array.size());
System.out.println(lis);
}
public void shuffle(){
System.out.println("随机混排列表元素");
System.out.println("随机混排列表前元素");
System.out.println(array);
Collections.shuffle(array,new Random());
System.out.println("随机混排列表后元素");
System.out.println(array);
}
public void prin(){
prinAll();
IndexPrin();
shuffle();
}
}
public class Test{
public static void main(String[] arges){
PlayArrayList P=new PlayArrayList();
P.prin();
}
}
示例2
/**
*这个程序演示LinkedList用法
*/
import java.util.LinkedList;
class LinkedListClass{
private LinkedList lis;
public LinkedListClass(){
lis=new LinkedList();
}
public void AddLinkedList(Object obj){
lis.addLast(obj);
}
public void RemoveLinkedList(){
lis.removeFirst();
}
public boolean RemoveLinkedList(Object obj){
return lis.remove(obj);
}
public void Addprin(){
AddLinkedList("c");
AddLinkedList("Java");
AddLinkedList("SQL");
AddLinkedList(".NET");
System.out.println("此队列的数据包括");
System.out.println(lis);
}
public void RemovePrin(){
RemoveLinkedList();
System.out.println("删除第一个元素后队列的数据包括");
System.out.println(lis);
if(RemoveLinkedList("Java")){
System.out.println("删除Java后队列的数据包括");
System.out.println(lis);
}else{
System.out.println("列表中不包含Java");
}
}
public void prin(){
Addprin();
RemovePrin();
}
}
public class Test{
public static void main(String[] arges){
LinkedListClass L=new LinkedListClass();
L.prin();
}
}
示例3
/**
*演示Vector的用法
*
*/
import java.util.Vector;
class VectorClass{
private Vector Vec;
public VectorClass(){
Vec=new Vector();
}
public void Add(){
Vec.addElement("C");
Vec.addElement("Java");
Vec.addElement("SQL");
Vec.addElement(".NET");
}
public void insert(){
Vec.insertElementAt("宝石",0);
Vec.insertElementAt("黄金",1);
Vec.insertElementAt("白银",4);
Vec.insertElementAt("珍珠",5);
}
public void select(){
if(Vec.contains("Java")){
System.out.println("****************************");
System.out.println("在索引"+Vec.indexOf("Java")+"找到Java");
}
}
public void Delete(){
if(Vec.remove("Java")){
System.out.println("****************************");
System.out.println("删除Java后的列表:");
System.out.println(Vec);
}
}
public void prin(){
System.out.println("****************************");
System.out.println("添加后的列表!");
Add();
System.out.println(Vec);
System.out.println("****************************");
System.out.println("插入后的列表!");
insert();
System.out.println(Vec);
select();
Delete();
System.out.println("****************************");
System.out.println("第一个元素!");
System.out.println(Vec.firstElement());
System.out.println("****************************");
System.out.println("最后一个元素!");
System.out.println(Vec.lastElement());
System.out.println("****************************");
System.out.println("默认容量!");
System.out.println(Vec.capacity());
}
}
public class Test{
public static void main(String[] arges){
VectorClass V=new VectorClass();
V.prin();
}
}
/**
*此示例演示HashMap的用法
***/
package maps;
import java.util.HashMap;
public class Test {
private HashMap map;
public Test()
{
map=new HashMap();
}
//添加Map
public void addMap()
{
Student stu1=new Student(1,"name1",60.08);
Student stu2=new Student(2,"name2",70.08);
Student stu3=new Student(3,"name3",80.08);
Student stu4=new Student(4,"name4",90.08);
map.put(stu1.getSno(), stu1);
map.put(stu2.getSno(), stu2);
map.put(stu3.getSno(), stu3);
map.put(stu4.getSno(), stu4);
}
//添加Map，如果Key存在则替换key对应的值，并返回替换的值。
public Object addMap(Object key,Object value)
{
return this.map.put(key, value);
}
//检查KEY
public boolean ContainsKey(Object key)
{
if(map.containsKey(key))
{
return true;
}else
{
return false;
}
}
//检查Value
public boolean ContainsValue(Object value)
{
if(map.containsValue(value))
{
return true;
}else
{
return false;
}
}
//获取Map大小
public int getSize()
{
return this.map.size();
}
//根据Key值移除元素，并返回移除的元素
public Object remove(Object key)
{
if(this.map.containsKey(key))
{
return this.map.remove(key);
}else
{
return null;
}
}
public static void main(String[] arges)
{
}
}
//Student 类
package maps;
public class Student {
private Integer sno;
private String sname;
private Double smark;
public Student(){}
public Student(Integer sno,String sname,Double smark)
{
this.sno=sno;
this.sname=sname;
this.smark=smark;
}
public Integer getSno() {
return sno;
}
public void setSno(Integer sno) {
this.sno = sno;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Double getSmark() {
return smark;
}
public void setSmark(Double smark) {
this.smark = smark;
}
}
|
|
|
