package com.wlh.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestList {
public static void main(String[] args) {
Collection c = new ArrayList();
//可以放入不同类型的对象
c.add("hello");
c.add(new Name("f1", "l1"));
c.add(new Name("f1", "l1"));
c.add(11);//整型11将自动打包为对象new Integer(11);
c.add(22);//整型12将自动打包为对象new Integer(11);
//返回包含此 collection 中所有元素的数组
Object [] obj=c.toArray();
for(int i=0;i<obj.length;i++){
System.out.println("obj"+i+":"+obj[i]);
}
Collection cc = new ArrayList();
cc.add("hello");
cc.add(11);
cc.add("hello world");
//contains方法:如果此 collection 包含指定的元素,则返回 true
System.out.println(c.contains("hello"));//true
//containsAll: 如果此collection 包含指定 collection 中的所有元素,则返回 true。
System.out.println(c.containsAll(cc));//false
//addAll: 将指定 collection 中的所有元素都添加到此 collection 中
System.out.println(c.addAll(cc));
//retainAll:交集,仅保留此 collection 中那些也包含在指定 collection 的元素(可选操作)。
//System.out.println(c.retainAll(cc));
//removeAll: 移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。
System.out.println(c.removeAll(cc));
//ArrayList为什么有两个remove方法?
//remove(int index) 是子类新添加的!
//如果是父类引用指向子类对象,则找不到子类中新添加的方法。
//要想调用子类新添加的方法,需要先转型
//是优先自动打包呢?还是先去匹配方法?
c.remove("hello1");
System.out.print(c);
//要想调用子接口中新添加的方法,需要先转型
List a = (List) c;
a.remove(1);
System.out.println(c.size());
System.out.println(c);
//clear:移除此 collection 中的所有元素(父接口Collection中的方法clear)
c.clear();
System.out.println(c);
}
}
class Name {
private String firstName, lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
//重写了tostring方法
public String toString() {
return firstName + "" + lastName;
}
}
package com.wlh.collection;
//为什么调用两次c.add("hello");只加入一个hello?
//可见HashSet中是采用了比较元素hashCode的方法来判断元素是否相同(duplicate),
//而不是采用其他类似equals之类的东东来判断。
//一个对象被当作Map里面的key的时候,hashCode用来比较两个东东是不是相等
//hashCode非常适合用来做索引
//重写equals方法,通常需要重写hashCode方法.因为你的本意是想让他相等的.但hashCode如果不重写,不同的对象就不会相等
import java.util.*;
public class BasicContainer {
public static void main( String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add("hello");
c.add(new Name3("f1","l1"));
c.add(new Name3("f1","l1"));
System.out.println(new String("f1").hashCode()==new String("f1").hashCode());
c.add(new Integer(100));
c.remove("hello");
c.remove(new Integer(100));
System.out.println(c.remove(new Name3("f1","l1")));
//System.out.println(c);
System.out.println(new Name3("f1","l1").hashCode());
System.out.println(new Name3("f1","l1").hashCode());
System.out.println(c);
List list = new ArrayList();
list.add(new Name3("f2", "l2"));
list.add(new Name3("f1", "l1"));
list.add(new Name3("f5", "l5"));
list.add(new Name3("f3", "l3"));
Collections.sort(list);
System.out.println(list);
}
}
class Name3 implements Comparable
{
public String firstName,lastName;
public Name3(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
@Override
public String toString() {
return firstName + " " + lastName;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name3 name = (Name3) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
@Override
public int hashCode() {
System.out.println(firstName.hashCode());
return firstName.hashCode();//这个对象当作为索引的时候会使用
}
public int compareTo(Object o) {
Name3 n = (Name3)o;
int lastCmp =
lastName.compareTo(n.lastName);
return
(lastCmp!=0 ? lastCmp :
firstName.compareTo(n.firstName));
}
}
package com.wlh.collection;
import java.util.Collection;
import java.util.HashSet;
public class TestSet {
/**
* Set通过验证hashcode来判断2元素是否相等,先调用hashcode方法然后调用equals方法
*/
public static void main(String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add("hello");
c.add(new Name4("f1","l1"));
c.add(new Name4("f1","l1"));
System.out.println(c);
}
}
class Name4 //implements Comparable
{
public String firstName,lastName;
public Name4(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
@Override
public String toString() {
return firstName + " " + lastName;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Name4) {
Name4 name = (Name4) obj;
System.out.println(firstName.equals(name.firstName));
return (firstName.equals(name.firstName));
}
return super.equals(obj);
}
@Override
public int hashCode() {
System.out.println(firstName.hashCode());
return firstName.hashCode();//这个对象当作为索引的时候会使用
}
/*public int compareTo(Object o) {
Name4 n = (Name4)o;
int lastCmp =
lastName.compareTo(n.lastName);
return
(lastCmp!=0 ? lastCmp :
firstName.compareTo(n.firstName));
}*/
}
package com.wlh.collection;
import java.util.HashSet;
import java.util.Set;
public class SetTest5 {
public static void main(String[] args){
Set set = new HashSet();
set.add(new SetElement5("aa"));
set.add(new SetElement5("aa"));
set.add(new SetElement5("bb"));
System.out.println(set);
}
static class SetElement5{
String s;
public SetElement5(String s){
this.s = s;
}
public String toString(){
return s;
}
public boolean equals(Object obj) {
System.out.println(s.equals(((SetElement5)obj).s));
return s.equals(((SetElement5)obj).s);
}
public int hashCode() {
System.out.println(s.hashCode());
return s.hashCode();
}
}
}
package com.wlh.collection;
import java.util.Set;
import java.util.*;
/**
* TreeSet中是采用Comparable接口中的compareTo方法来判断元素是否相同(duplicate),
* 而不是采用其他类似equals之类的东东来判断。
* @author Administrator
*
*/
public class TreeSetTest {
public static void main(String[] args){
Set set = new TreeSet();
set.add(new SetElement2("aa"));
set.add(new SetElement2("aa"));
set.add(new SetElement2("bb"));
System.out.println(set);
}
static class SetElement2 implements Comparable{
String s;
public SetElement2(String s){
this.s = s;
}
public String toString(){
return s;
}
public int compareTo(Object o){
return s.compareTo(((SetElement2)o).s);
}
public boolean equals(Object obj) {
return s.equals(((SetElement2)obj).s);
}
}
}
package com.wlh.collection;
import java.util.*;
class TestMap2 {
public static void main(String args[]) {
Map m1 = new HashMap();
m1.put("one",new Integer(1));
m1.put("one",new Integer(7));
m1.put("two",new Integer(2));
m1.put("three",new Integer(3));
m1.put(new Name2("f1","l1"),"aaa");
m1.put(new Name2("f1","l1"),"bbb");
m1.put(new Name2("f1","l1"),"bbb");
//m1.remove(new Name("f1","l1"));
//System.out.println(m1);
//System.out.println(m1.size());
//System.out.println(m1.containsKey("one"));
if(m1.containsKey("two")) {
int i = ((Integer)m1.get("two")).intValue();
//System.out.println(i);
}
Map m2 = new TreeMap();
//m2.put("B","aaa");
m2.put(new Name2("f1","l1"),"aaa");
m2.put(new Name2("f1","l1"),"aaa");
System.out.println(m2);
//System.out.println(m2.containsValue("aaa"));
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);
}
}
class Name2
implements Comparable
{
public String firstName,lastName;
public Name2(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
@Override
public String toString() {
return firstName + " " + lastName;
}
@Override
public boolean equals(Object obj) {
System.out.println("equals.....");
if (obj instanceof Name) {
Name2 name = (Name2) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
@Override
public int hashCode() {
//System.out.println("==="+firstName.hashCode());
System.out.println("hashCode.....");
return firstName.hashCode();//这个对象当作为索引的时候会使用
}
public int compareTo(Object o) {
System.out.println("compareTo.....");
Name2 n = (Name2)o;
int lastCmp = lastName.compareTo(n.lastName);
return
(lastCmp!=0 ? lastCmp : firstName.compareTo(n.firstName));
}
}
分享到:
相关推荐
《压力容器类设备预算与报价软件详解》 在工业领域,压力容器类设备的预算与报价是一项关键工作,涉及到工程项目的成本控制、盈利预测以及竞标策略。为提高工作效率和准确性,专门的压力容器类设备预算、报价小软件...
实现电话号码本的管理和查询功能。号码本内预先存储了若干条联系人记录,记录内容包括联系人姓名和电话号码。...必须使用容器类作为内部数据结构,可自行选择合适的容器类; 必须把联系人记录定义成一个类;
Java容器类是Java编程语言中不可或缺的一部分,它们主要用于存储和管理对象。这些类和接口位于`java.util`包中,为开发者提供了灵活的数据结构和数据操作方式。在Java中,容器类主要分为两大类:Collection和Map。 ...
Qt 容器类详解 Qt 容器类是 Qt 框架中的一种基本数据结构,用于存储和管理数据。 Qt 容器类可以分为连续容器和链表两大类别。连续容器类包括 QVector、QList,链表类包括 QLinkedList。 QVector<T> 是一种与数组...
参考JavaSE8,全面囊括了所有Java容器类,以Collection为基类,使用不同颜色不同的继承体系分支进行标识。
Java容器类是Java集合框架的重要组成部分,它们提供了一种存储、管理和操作对象的方式。在Java中,容器类包括数组、列表、队列、集、映射等数据结构,它们为开发者提供了灵活的数据处理能力。本篇文章将深入探讨Java...
Java容器类,也称为集合类,是Java编程中用于存储和管理对象的重要工具。它们提供了比数组更加灵活和强大的功能,适用于各种复杂的数据结构需求。本文主要探讨Java容器类的基本概念、特点以及不同类型的容器。 首先...
### Java 容器类解析及对比 #### 一、概述 在Java开发中,容器类是程序员必须掌握的基础知识之一。本文将详细解析并对比Java中的各种容器类,特别是`Collection`、`List`、`ArrayList`、`Vector`以及`Map`、`...
在编程领域,容器类是数据结构的一个重要组成部分,它们用于存储和管理一组对象。容器类在C++标准库中有着广泛的应用,如`std::vector`、`std::list`、`std::set`和`std::map`等。本节我们将通过实例深入探讨容器类...
Java容器类是Java编程中非常重要的一部分,它们为数据存储提供了丰富的结构和操作。本文主要关注的是Java中的两种主要容器类型:Collection和Map,以及它们的一些具体实现,如List接口下的ArrayList、LinkedList和...
### C++ 容器类与 Qt 容器详解 #### C++ 容器类概述 在C++标准库中,容器类(containers)是用于存储数据的重要组件之一,它们为程序设计提供了高度灵活且功能丰富的数据管理手段。根据数据的组织形式不同,C++中...
在Java编程语言中,容器类是集合框架的重要组成部分,它们为组织、管理和操作对象提供了强大的工具。本章将深入探讨Java中的容器类,包括ArrayList、LinkedList、HashSet、HashMap等,以及它们在实际开发中的应用。 ...
【C++编程思想/模板和容器类】 C++中的模板是一种强大的工具,它允许程序员创建泛型代码,即代码能够处理多种数据类型。模板的概念在C++中扮演着至关重要的角色,尤其是对于实现容器类,如向量、列表、集合等。容器...
Java容器类是Java编程中的核心概念,主要用于存储和管理对象。在Java程序设计课程中,容器类的教学至关重要,因为它们提供了动态数据结构,使得开发者能够高效地组织和操作数据。然而,由于容器类的深入理解需要数据...
本篇文章将深入探讨MFC中的基本容器类,包括其特性、分类、使用方法以及指针类型的容器类。 首先,MFC提供了三种基本的容器类:arrays(数组)、lists(链表)和maps(映射,也称为字典)。这些容器类允许开发者...
本篇文章将详细讲解容器的分类,重点探讨Java中的集合框架,包括List、Set以及重写toString方法的重要性,同时也会简单提及Collections类的使用。 首先,我们来了解容器的分类。在Java中,容器主要分为两大类:集合...
Java容器类List、ArrayList、Vector及map、HashTable应用 List、ArrayList、Vector及map、HashTable是Java中常用的容器类,它们都继承自Collection接口,并提供了不同的实现方式和特点。在实际开发中,选择合适的...
Java容器类是Java集合框架的重要组成部分,它为处理对象集合提供了数据结构和算法的支持。本篇文章将重点介绍Java容器类中Collection接口、Map接口、Iterator接口以及List、Set和Map的实现类。 首先,Collection...
在本场景中,我们讨论的是一个基于容器类的人力资源(HR)管理系统,其主要涉及部门和雇员的管理功能。 首先,容器类在编程中扮演着重要角色,它是一种可以容纳其他对象的数据结构。在Java中,例如ArrayList、...