集合（Collection,set,list,map)

package cn.hncu.col.col;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CollectionDemo {

public static void main(String[] args) {

Collection col = new ArrayList(); //addA(Object obj); --List的实现类
//Collection col = new HashSet(); //--Set的实现类--重复元素是加不进的，元素的排列序列由各元素的hashCode值来决定

//增
col.add(1);
col.add("abc");
col.add(100.123);
col.add("asd");
//col.add(1);//如果该Collection用的是Set的实现类，那么重复的元素是加不进的
col.add( new Person("Jack",22) );

//删除
//col.remove("abc");
//String str = new String("abc");
//col.remove(str);

//修改1(对于Set实现，这种方式可以。而List实现不行，顺序乱了)
//col.remove("abc");
//col.add("abc123");

//修改2
Object[] objs = col.toArray();
col.clear();
for(int i=0;i<objs.length;i++){
if(objs[i].equals("abc")){
objs[i] = "abc123";
}
col.add(objs[i]);
}

//查
//集合遍历---工具：Iterator
Iterator it = col.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}

}

}

----------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//有序，允许重复。总的来讲: List中的功能是在Collecton的基础上还添加了“与下标索引”有关的操作
/*
* 1, List当中，元素添加的顺序和存入的顺序是一样的---跟hashCode没有关系
* 2, List当中有一些“与位置-index”有关的操作
* 3, List当中有一个ListIterator列表迭代器，既可以next()，也可以previous()----而Collection当中的Iterator只能next()
*/
public class ListDemo {

public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add(0,"d");//在基础上增加的---与index有关的操作

list.add(new Person("Rose",23));
list.add(new Person("Jack",25));
list.add(new Person("Jack",25));
list.add(new Person("Tom",22));

//删除
//list.remove("b");
//list.remove(2);

//修改
//list.set(3,"ccc");//修改第3个位置的元素
int index = list.indexOf("c");
list.set(index, "ccccc");

//遍历法1：用迭代器
// Iterator it = list.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
//遍历法2：利用与位置有关的操作，直接采用for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}

}

}

----------------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

//有序，允许重复。总的来讲: List中的功能是在Collecton的基础上还添加了“与下标索引”有关的操作
/*
* 1, List当中，元素添加的顺序和存入的顺序是一样的---跟hashCode没有关系
* 2, List当中有一些“与位置-index”有关的操作
*/
public class ListDemo2 {

public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add("a");
list.add("b");
list.add("c");
list.add(new Person("Jack",25));
list.add(new Person("Tom",22));

//※※LinkedList当中特有的方法
//list.addFirst("11111");
list.addLast("22222");
list.removeFirst();
//list.removeLast();
//getFirst()、getLast()

//遍历法2：利用与位置有关的操作，直接采用for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}

}

------------------------------------------------------------

package cn.hncu.col.list;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class MyStack {
//private List list = new ArrayList();//允许重复，有序
private List list = new LinkedList();//允许重复，有序--中间元素有频繁的插入和删除，选这个

//入栈
public void push(Object obj){
list.add(obj);
}

//出栈
public Object pop(){
if(list.size()>0)
return list.remove( list.size()-1 );
else
return null;
}

//大小
public int size(){
return list.size();
}

public static void main(String[] args) {
MyStack stack = new MyStack();
stack.push("a");
stack.push("b");
stack.push(new Person("Mike",20));
stack.push(100);

for (int i = 0; i < 5; i++) {
System.out.println(stack.pop());
}
}

}

----------------------------------------------------

package cn.hncu.col.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

//无序，不允许重复。总的来讲: Set中的全部功能都来自Collecton，自己没有添加新的功能
public class HashSetDemo {
/*
* 1,如果Person类中没写hashCode()，那么构造两个相同的Person对象也能加进Set集合，因此此时的HashCode是内存地址。而如果写了hashCode()方法，则第二个加不进。
* 2,set.add(e)方法执行时，内部会调用一次e对象的hashCode()方法(其实根据它的返回值来决定元素存放位置)
* 3,如果Person类中没写hashCode()，加入到集合中的这些元素的顺序是不确定的(因为此时各元素的位置由内存地址来决定的)
*/
public static void main(String[] args) {
Set set = new HashSet();
set.add(new String("Java"));
set.add( new Person("Jack",23) );//hashCode
set.add( new Person("Jack",23) );//加不进，相同的hashCode处，只能加入一个元素
set.add( new Person("Tom",23) );
set.add( new Person("张三",22) );
set.add(new Integer(100) );
set.add(new Double(100.123) );

//Set一般都是用迭代器(专门的查询组件)来遍历
Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
//区分集合当中元素的类型 ---instanceof
if(obj instanceof Person){
System.out.println("Person对象:"+obj);
}else if(obj instanceof Integer || obj instanceof Double){
System.out.println("数值:"+obj);
}else{
System.out.println(obj);
}
}

}

}

--------------------------------------------------------------

package cn.hncu.col.sort.v1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo1 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序
set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("张三",33));
set.add(new Person("Rose",24));

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------------------------------------------------

package cn.hncu.col.sort.v2;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo2 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序

set.add("abc");
set.add("aaa");

set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("Mik",32));
set.add(new Person("张三",32));
set.add(new Person("Rose",24));

//set.add("abc");//因为String类中没有compartTo(Person)的方法，所以在这个地方添加不行。
//set.add("aaa");

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------------------------------------------

package cn.hncu.col.sort.v3;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo3 {

public static void main(String[] args) {
//Set set = new TreeSet();//TreeSet是要排序的。如果是空参构造方法，那么顺序由被添加元素来决定(使用它的Comparable接口)---排序方法1
Comparator cmp= new MyCmp();
Set set = new TreeSet(cmp);//使用有Comparator参数的构造。利用cmp比较器来进行排序，不会使用被添加元素的Comparable接口
set.add("abc");
set.add("aaa");

set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("Mik",32));
set.add(new Person("张三",32));
set.add(new Person("Rose",24));

//set.add("abc");
//set.add("aaa");

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

-------------------------------------------------

package cn.hncu.col.sort.v3;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class SortDemo4 {

public static void main(String[] args) {

//如果是TreeMap，是按key来排序的
Comparator cmp= new MyCmp();
Map map = new TreeMap(cmp);//使用有Comparator参数的构造。利用cmp比较器来进行排序，不会使用被添加元素的Comparable接口
// map.put(1, "abc");
// map.put(2, "aaa");

map.put(3, new Person("Jack",102));
map.put(4, new Person("Tom",23));
map.put(5, new Person("Mike",32));
map.put(6, new Person("Mik",32));
map.put(7, new Person("张三",32));
map.put(8, new Person("Rose",24));

map.put(9, "abc");
map.put(81, "aaa");

Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry en = (Entry) it.next();
System.out.println(en.getKey()+":"+en.getValue());
}
}

}

------------------------------------------------------------

****中文排序

package cn.hncu.col.sort.v4;

import java.util.Iterator;
import java.util.TreeMap;
import java.util.Map.Entry;

public class ChineseSort {
public static void main(String[] args) {
TreeMap map = new TreeMap( new MyCmp2() );
map.put("周平", new Person("周平",10));
map.put("张三", new Person("张三",22));
map.put("李四", new Person("李四",34));
map.put("一丁", new Person("一丁",3));

Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry en = (Entry) it.next();
System.out.println("key="+en.getKey()+",,,value="+en.getValue());
}
}
}

---==================--------

package cn.hncu.col.sort.v4;

import java.text.CollationKey;
import java.text.Collator;
import java.util.Comparator;
/**
* 中文排序的比较器
* @author <a href="mailto:[email protected]">hncu_lzp</a>
* @version 1.0 2016-7-15
*/
public class MyCmp2 implements Comparator {
private Collator collator = Collator.getInstance();
@Override
public int compare(Object o1, Object o2) {

CollationKey key1 = collator.getCollationKey(o1.toString());
CollationKey key2 = collator.getCollationKey(o2.toString());
return key1.compareTo(key2);//把key1和key2交换一下，则是反序排序
}
}

----------------------------------------------------------------------

package cn.hncu.col.sort.v1;

public class Person implements Comparable{
private String name;
private int age;

public Person(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 int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) 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;
}

@Override
public String toString() {
return name + "," + age;
}

=====这里公用一个person类，有的要hashcode和equals方法，有的不需要。下面是因为要用到Tree。

//由该方法的返回值来决定元素this和o之后的大小
/**
* 计算：this - o
* 如果this>o 返回 >0的整数
* 如果this<o 返回 <0的整数
* 如果this==o 返回 0
*/
@Override
public int compareTo(Object o) {
//System.out.println("a.........");
//return 1; //后加的元素更大，按添加的次序依次排(输出)
//return -1; //后加的元素更小，按添加的次序的倒序排(输出)
Person p = (Person) o;
//return this.age - p.age;//按年龄升序
return p.age - this.age;//按年龄倒序
}

}

-----------------------------------------------------

package cn.hncu.col.sort.v1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SortDemo1 {

public static void main(String[] args) {
//Set set = new HashSet();//HashSet是无法实现:自定义排序
Set set = new TreeSet();//TreeSet可以实现:自定义排序 ----凡是Tree都能实现自定义排序
//凡是插入TreeSet中的元素应该都是能够排序的，即要实现Comparable接口
//TreeSet中的add()方法被调用时，会自动让被添加元素去调用它的compareTo()方法以决定该元素的顺序
set.add(new Person("Jack",102));
set.add(new Person("Tom",23));
set.add(new Person("Mike",32));
set.add(new Person("张三",33));
set.add(new Person("Rose",24));

Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}

}

--------------------

时间： 2024-11-20 18:43:08

集合（Collection,set,list,map)的相关文章

java集合 - Collection - List - Set - Map - Iterator 学习笔记

1.Collection接口 集合可以理解为一个动态的对象数组,两层含义: 1).动态:集合中的对象可以任意扩充和删减: 2).集合中可以存放任意对象. 集合的性能比数组高,而且更容易进行数据的扩展和修改. Collection的常用子接口:List.Set.Queue. 2.List接口 List集合可以存放任意对象,而且集合中对象可以重复. List的常用实现类:ArrayList.Vector. ArrayList与Vector的比较: 性能方面:ArrayList采用异步处理方式,性能高

Java基础集合Collection Map的概述

概述: 1,jse-collection分类,主要讲解Collection和Map接口的子类及其接口和相关工具类(不含线程安全的集合类). 2,本节介绍一下整体集合框架的结构图. 一.关于java集合涉及到的基本数据结构和算法的理论(这里试试简单的给大家一些参考). 数组(Array),在中间位置插入.删除效率低下,但是按位置索引查找快.链(Linked),在中间位置插入.删除效率高,按位置索引查找效率低下.树.散列. ---------------集合(Set),无序.不重复的原始集合.列表(

Java集合排序及java集合类详解--(Collection, List, Set, Map)

1         集合框架 1.1         集合框架概述 1.1.1         容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情. 举例来说,假设要存储许多雇员,不同的雇员的区别仅在于雇员的身份证号.我们可以通过身份证号来顺序存储每个雇员,但是在内存中实现呢?是不是要准备足够的内存来存储1000个雇员,然后再将这些雇员逐一插入?如果已经插入了500条记录,这时需要插入一个身份证号较低的新雇员,该怎么办呢?是在内

java.util (Collection接口和Map接口)

1:Collection和Map接口的几个主要继承和实现类                  1.1  Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的"子接口"如List和Set. 如

JAVA中Collection接口和Map接口的主要实现类

Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set. 所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collectio

黑马程序员——Java基础---集合（二）------Map集合

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- Map集合 一.概述 1.简述: Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key) 2.特点: 1)该集合存储键值对,一对一对往里存 2)要保证键的唯一性

java集合Collection接口

collection集合 Map集合 Collection接口 Collection接口是List.Set和Queue接口的父接口,该接口里定义的方法既可用于操作Set集合,也可用于操作List和Queue集Collection提供了大量添加.删除.访问的方法来访问集合元素.主要的方法如下:

【转】Java 集合系列09之 Map架构

概要 前面,我们已经系统的对List进行了学习.接下来,我们先学习Map,然后再学习Set:因为Set的实现类都是基于Map来实现的(如,HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的). 首先,我们看看Map架构. 如上图:(01) Map 是映射接口,Map中存储的内容是键值对(key-value).(02) AbstractMap 是继承于Map的抽象类,它实现了Map中的大部分API.其它Map的实现类可以通过继承AbstractMap来减少重复编码.

Java 集合系列09之 Map架构

概要 前面,我们已经系统的对List进行了学习.接下来,我们先学习Map,然后再学习Set:因为Set的实现类都是基于Map来实现的(如,HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的). 首先,我们看看Map架构. 如上图:(01) Map 是映射接口,Map中存储的内容是键值对(key-value).(02) AbstractMap 是继承于Map的抽象类,它实现了Map中的大部分API.其它Map的实现类可以通过继承AbstractMap来减少重复编码.

java 容器Collection List Set Map概述

对JAVA的集合的理解是想对于数组 数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型) JAVA集合可以存储和操作数目不固定的一组数据. 所有的JAVA集合都位于 java.util包中! JAVA集合只能存放引用类型的的数据,不能存放基本数据类型. JAVA集合主要分为三种类型: Set(集) List(列表) Map(映射) Collection 接口 Collection是最基本的集合接口,声明了适用于JAVA集合(只包括Set和List)的通用方法. Set 和