补充:自定义对象时,覆盖Object类中的equals方法和Hashcode方法,实现Comparable接口
为什么出现集合(collection)
对象多了用集合存 ,数据多了用对象
只存储对象,长度可变
体系
Collection
|-List:元素有序,可重复,该集合有所引
|-ArrayLisr :数组,查询速度快,增删慢,默认长度为10,增加50%,
|-LinkedList:双向循环链表,查询速度慢,增删快
|-Vector :数组结构,速度很慢,线程同步,被ArrayList替代了
|-Set:元素无序,不可重复
|-HashSet:Hash表,线程不同步
|-TreeSet :二叉树
-------------------List-------------------
注意:equals方法保证元素唯一
各个集合特有方法
(1)Collection
增boolean add(E e)
确保此 collection 包含指定的元素(可选操作)。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中(可选操作)。
删
void clear()
移除此 collection 中的所有元素(可选操作)。
boolean remove(Object o)
从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。
判断
boolean isEmpty()
如果此 collection 不包含元素,则返回 true。
boolean contains(Object o)
如果此 collection 包含指定的元素,则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素,则返回 true。
转成数组
Object[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
(2)List
1、增
void add(String item)
向滚动列表的末尾添加指定的项。
void add(String item, int index)
向滚动列表中索引指示的位置添加指定的项。
2、删
void remove(int position)
从此滚动列表中移除指定位置处的项。
3、改
set(index,element)
4、查
get(index)
subList(from,to)
ListIterator()
(3)ListIterator
List特有,操作中不允许使用集合方法操作元素,会发生ConcurrentModificationException
增
void add(E e)
将指定的元素插入列表(可选操作)。
删
void remove()
从列表中移除由 next 或 previous 返回的最后一个元素(可选操作)。
改
void set(E e)
用指定元素替换 next 或 previous 返回的最后一个元素(可选操作)。
反向遍历
boolean hasPrevious()
如果以逆向遍历列表,列表迭代器有多个元素,则返回 true。
(4)Vector(特有取出方式枚举)
Enumeration<E> elements()
返回此向量的组件的枚举。
(5)Enumeration
(此接口的功能与 Iterator 接口的功能是重复的。此外,Iterator 接口添加了一个可选的移除操作,并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。 )
boolean hasMoreElements()
测试此枚举是否包含更多的元素。
E nextElement()
如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素。
(6)LinkedList
1、增
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
2、删
E removeFirst()
移除并返回此列表的第一个元素。
boolean removeFirstOccurrence(Object o)
从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)。
E removeLast()
移除并返回此列表的最后一个元素。
boolean removeLastOccurrence(Object o)
从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)。
3、查
E getFirst()
返回此列表的第一个元素。
E getLast()
返回此列表的最后一个元素。
后替代方法(出后缀是first和last的方法是1.6出现的,其他1.5出现的)
1、增
boolean offer(E e)
将指定元素添加到此列表的末尾(最后一个元素)。
boolean offerFirst(E e)
在此列表的开头插入指定的元素。
boolean offerLast(E e)
在此列表末尾插入指定的元素。
2、删
E peek()
获取但不移除此列表的头(第一个元素)。
E peekFirst()
获取但不移除此列表的第一个元素;如果此列表为空,则返回 null。
E peekLast()
获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null。
3、查
E poll()
获取并移除此列表的头(第一个元素)
E pollFirst()
获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast()
获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
一、HashSet
1、元素唯一:通过,Hashcode和equals方法保证元素唯一,当Hash地址一样时,在调用equlas判断,如果不同那就把对象接到相同地址后面,这也是判断和删除的依据。
二、TreeSet
1、元素唯一:comparaTo方法 return 0;
特殊接口:public interface Comparable<T>此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
复写
int compareTo(T o)
比较此对象与指定对象的顺序。
2、元素排序
方式方法一:
让元素自身具有比较性,实现Coparable接口,覆盖compareTo方法也称元素自然排序或默认顺序
方式二:
当元素本身不具备比较性,或者不是所需的。这时让集合自身具备,集合初始化时,就具备比较性,构造时,传入比较器对象。定义一个类实现Comparator接口,覆盖compare()方法。
-------------------Map-------------------
Map
|-Hashtable : 哈希表,不允许null健和null值,同步,1.0,低
|-HashMap :哈希表,允许null健和null值,不同步,1.2,高
|-TreeMap : 二叉树,给map健排序,不同步,和Set很像,Set底层使用Map
特点:键值对,一对一对向里存,健必须唯一
常用方法:
添加
V put(K key, V value) ,新value替换原来的value,返回原来的
将指定的值与此映射中的指定键关联(可选操作)。
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。
删
void clear()
从此映射中移除所有映射关系(可选操作)。
V remove(Object key)
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
获取
int size()
返回此映射中的键-值映射关系数。
Collection<V> values()
返回此映射中包含的值的 Collection 视图。
V get(Object key)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet()
返回此映射中包含的键的 Set 视图。
2、取出方法
(1)keySet方法:将Map中的所有建存入set中,在用get方法
(2)entrySet方法: 将key和value封装成Map.Entry对象,里面包含Key和Value
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("01", "lisi");
map.put("03", "wanger");
map.put("01", "lisi");
print2(map);
}
//keySet取出方法
public static void print1(Map<String, String> map) {
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext()) {
String key = it.next();
System.out.println(key + ": " + map.get(key));
}
}
//entrySet取出方式
public static void print2(Map<String, String> map) {
Set<Map.Entry<String, String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while(it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
3、一对多关系
(不过开发中,学号都封装在学生对象中)
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 一个班级是一个HashMap,key-学号,value-学生对象
* 将班级再存入HashMap, key-班级名称,value-班级HashMap
* @author renpingqing
*/
public class TestMap1 {
public static void main(String[] args) {
//预热班级
HashMap<String,Student1> yrb = new HashMap<String,Student1>();
yrb.put("01", new Student1("lisi"));
yrb.put("03", new Student1("wanger"));
yrb.put("02", new Student1("li"));
//冲刺班级
HashMap<String,Student1> ccb = new HashMap<String,Student1>();
ccb.put("03", new Student1("ersi"));
ccb.put("05", new Student1("wanger"));
ccb.put("02", new Student1("li"));
//将班级添加到一个集合中,
HashMap<String,HashMap<String,Student1>> classs =
new HashMap<String,HashMap<String,Student1>>();
classs.put("预热班", yrb);
classs.put("冲刺班", ccb);
print(classs);
}
//遍历
public static void print(HashMap<String,HashMap<String,Student1>> map) {
Set<Map.Entry<String, HashMap<String, Student1>>> entrySet1 = map.entrySet();
Iterator<Map.Entry<String, HashMap<String, Student1>>> it1 = entrySet1.iterator();
while(it1.hasNext()) {
Map.Entry<String, HashMap<String, Student1>> mapEntry1 = it1.next();
System.out.println(mapEntry1.getKey());
HashMap<String,Student1> map1 = mapEntry1.getValue();
Set<Map.Entry<String, Student1>> entrySet2 = map1.entrySet();
Iterator<Map.Entry<String, Student1>> it2 = entrySet2.iterator();
while(it2.hasNext()) {
Map.Entry<String, Student1> map2 = it2.next();
System.out.println(" " + map2.getValue().getName());
}
}
}
}
//学生对象
class Student1 {
private String name;
public Student1(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
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;
Student1 other = (Student1) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
-------------------2013-07-18以前总结-------------------
一、集合和数组区别:
1、集合:长度可变,只能存储对象,不同类型的对象
2、数组:长度固定
二、体系结构
Collection
|--List
|--ArrayList 数组,查询速度快,增删速度慢,线程不同步
|--LinkedList 链表,查询慢,增删快
|--Vector 数组,线程同步
|--Set
|--HashSet 哈希表,是通过元素的hashCode和equals方法,线程不同步
如果,元素的hashCode相等,才调用equals方法
注意:对于判断和删除都是依赖元素hashCode和equals方法
|--TraceSet 元素无序,存储自定义对象时,必须保证对象的可比较性,
第一种方式排序:让元素本身具备可比较性,即实现Comparable接口
覆盖compareTo方法,底层数据结构是二叉树,保证元素的唯一性是compareTo的返回结果
这种排序称为自然排序或者默认排序
第二种:当元素本身不具备可比较性或者,自身的比较性不是
我们所需要的,这时就让集合基本可比较性,在集合初始化时
就有了比较方法
为什么会出现这么多容器:
因为每个容器的对数据存储方式不一样,即数据结构
三、Map接口详解:存储的是键值对,键必须唯一
常用方法:
1、增
V put(K key, V value)
将指定的值与此映射中的指定键关联(可选操作)。
当键相同时,用新值替换旧值,并返回原来的值
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。
2、删
void clear()
从此映射中移除所有映射关系(可选操作)。
V remove(Object key)
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
3、判断
boolean containsKey(Object key)
如果此映射包含指定键的映射关系,则返回 true。
boolean equals(Object o)
比较指定的对象与此映射是否相等。
boolean isEmpty()
如果此映射未包含键-值映射关系,则返回 true。
4、获取
V get(Object key)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
int size()
返回此映射中的键-值映射关系数。
Collection<V> values()
返回此映射中包含的值的 Collection 视图。
重点:
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet()
返回此映射中包含的键的 Set 视图。
二、体系结构
Map
|--Hashtable:底层是哈希表,必须实现 hashCode 方法和 equals 方法。jdk1.0 效率低
不能存储null值和键,线程同步
|--HashMap:底层是哈希表,允许使用 null 值和 null 键。不同步jdk1.2 效率高
|--TreeMap :底层是二叉树,线程不同步,键排序
和set很像,其他set底层就是使用了Map集合
例1:TreeSet用比较构造器实现->按字符串长度排序
import java.util.*;
/*
TreeSet
按照字符串长度排序。小在前面
用容器本身,即比较器
*/
class StringLengthSort {
public static void main(String[] args) {
// TreeSet ts = new TreeSet(new MyComparator());
//内部类实现
TreeSet ts = new TreeSet(new Comparator() {
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
int num = s1.length() - s2.length();
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
});
ts.add("abcd");
ts.add("d");
ts.add("dddcd");
ts.add("abc");
ts.add("aaa");
Iterator it = ts.iterator();
while(it.hasNext()) {
out(it.next());
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
//比较器
class MyComparator implements Comparator {
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
int num = s1.length() - s2.length();
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
}
例2:TreeSet排序->用比较构造器实现
import java.util.*;
/*
TreeSet第二种排序:
当元素本身不具备可比较性或者,自身的比较性不是
我们所需要的,这时就让集合基本可比较性,在集合初始化时
就有了比较方法
具体实现:
定义一个比较器即,实现comparator,重写compare方法,将该
对象传入构造器方法
现在是存储顺序输出,用构造器实现姓名顺序输出
*/
//人类
class Person implements Comparable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//覆盖compareTo方法,使对象具有可比较性
public int compareTo(Object obj) {
// return 1;
return -1; //倒序输出
// return 0; //只能存储进去第一个元素
}
}
//main
class TreeSetSort {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new Mycompare());
//存储自定义对象
ts.add(new Person("lisi",12));
ts.add(new Person("lis",12));
ts.add(new Person("lii",13));
ts.add(new Person("lsi",14));
Iterator it = ts.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
out(p.getName() + "..." + p.getAge());
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
//比较器,按照年龄排序
class Mycompare implements Comparator {
public int compare (Object o1, Object o2) {
Person p1 = (Person)o1;
Person p2 = (Person)o2;
// return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
/*
if (p1.getAge() > p2.getAge()) {
return 1;
}
if (p1.getAge() < p2.getAge()) {
return -1;
}
return 0;
*/
}
}
例3:TreeSet原理详解->二叉树
import java.util.*;
/*
二叉树:值小的在节点左边。大的在节点右边,相等的只留一个
需求:
用TreeSet实现取出和存储顺序一样
*/
//人类
class Person implements Comparable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//覆盖compareTo方法,使对象具有可比较性
public int compareTo(Object obj) {
return 1;
// return -1; //倒序输出
// return 0; //只能存储进去第一个元素
}
}
//main
class TreeDataStructure {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
//存储自定义对象
ts.add(new Person("lisi",12));
ts.add(new Person("lis",12));
ts.add(new Person("lii",13));
ts.add(new Person("lsi",14));
Iterator it = ts.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
out(p.getName() + "..." + p.getAge());
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例4:TreeSet存储自定义对象
import java.util.*;
/* TreeSet:
元素无序,存储自定义对象时,必须保证对象的可比较性,即实现Comparable接口
覆盖compareTo方法
*/
//人类
class Person implements Comparable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//覆盖compareTo方法,使对象具有可比较性
public int compareTo(Object obj) {
if (!(obj instanceof Person)) {
throw new RuntimeException("不是人对象!");
}
Person p = (Person)obj;
if (this.age > p.age) {
return 1;
}
if (this.age == p.age) {
return this.name.compareTo(p.name);
}
return -1;
}
}
//main
class TreeTest {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
/*
像字符串这类的元素可以直接存储
ts.add("Java01");
ts.add("Java02");
ts.add("Java03");
*/
//存储自定义对象
ts.add(new Person("lisi",12));
ts.add(new Person("lis",12));
ts.add(new Person("lii",13));
ts.add(new Person("lsi",14));
Iterator it = ts.iterator();
while(it.hasNext()) {
Person p = (Person)it.next();
out(p.getName() + "..." + p.getAge());
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例5:用ArrayList实现队列和栈功能
import java.util.*;
/*
用ArrayList模拟
堆栈:先进后出
队列:先进先出
Author:renpingqing
Date:2013年7月17日 17:33:11
*/
//堆栈
class MyQueue {
private LinkedList al;
//构造函数
public MyQueue() {
al = new LinkedList();
}
//增加
public void add(Object obj) {
// al.add(obj); //堆栈
al.addFirst(obj); //队列
}
//获取
public Object get() {
return al.removeLast();
}
//是否为空
public boolean isNull() {
return al.isEmpty();
}
}
class QueueTest {
public static void main(String[] args) {
MyQueue m = new MyQueue();
m.add("java1");
m.add("java2");
m.add("java3");
while(!m.isNull()) {
out(m.get());
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例6:ArrayList存储自定义元素并去重
import java.util.*;
/*
存储自定义元素的容器,并去重
Author:renpingqing
Date:2013年7月17日 18:07:34
思路:
1、首先定义一容器
2、存储元素的时候,判断该容器中是否有该元素
注意:ArrayList判断元素重复是调用该对象的equals方法
*/
//人类
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//复写equals
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
return false;
}
}
//main
class SingleTest {
public static void main(String[] args) {
ArrayList al = new ArrayList();
//添加数据
al.add(new Person("李四",12));
al.add(new Person("张三",12));
al.add(new Person("李四",12));
al.add(new Person("王武",30));
out(al);
al = singleElement(al);
System.out.println();
out(al);
}
//输出元素
public static void out(ArrayList arr) {
//迭代器
Iterator it = arr.iterator();
while(it.hasNext()) {
Object obj = it.next();
//因为存储时对象向上转型成Object,所以使用时,要向下转型
if (obj instanceof Person) {
Person p = (Person)obj;
out(p.getName() + "..." + p.getAge());
}
}
}
//去重(相同姓名,相同年龄视为同一个人)
public static ArrayList singleElement(ArrayList al) {
ArrayList a = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if (obj instanceof Person) {
Person p = (Person)obj;
if (!a.contains(p)) { //contains是调用该对象的equals方法,我们必须复写
a.add(p);
}
}
}
return a;
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例7:HashSet只能存储单一元素原理详解
import java.util.*;
/*
HashSet存储自定义元素,
Author;renpingqing
Date:2013年7月17日 18:44:32
结论:HashSet存储和删除时,是先调用HashCode方法,如果相同,
则在调用equlas方法
*/
//人类
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//复写equals
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person p = (Person)obj;
HashSetTest.out(this.name + "...equlas..." + p.name); //测试用
return this.name.equals(p.name) && this.age == p.age;
}
return false;
}
//复写hashCode
public int hashCode() {
HashSetTest.out(this.name + "...hashCode"); //测试用
return name.hashCode() + age * 7;
// return 39;
}
}
//main
class HashSetTest {
public static void main(String[] args) {
HashSet hs = new HashSet();
//添加数据
hs.add(new Person("李四",12));
hs.add(new Person("张三",12));
hs.add(new Person("李四",12));
hs.add(new Person("王武",30));
out("");
out(hs);
}
//输出元素
public static void out(HashSet arr) {
//迭代器
Iterator it = arr.iterator();
while(it.hasNext()) {
Object obj = it.next();
//因为存储时对象向上转型成Object,所以使用时,要向下转型
if (obj instanceof Person) {
Person p = (Person)obj;
out(p.getName() + "..." + p.getAge());
}
}
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例8:ArrayList存储自定义元素并去重
import java.util.*;
/*
存储自定义元素的容器,并去重
Author:renpingqing
Date:2013年7月17日 18:07:34
思路:
1、首先定义一容器
2、存储元素的时候,判断该容器中是否有该元素
注意:ArrayList判断元素重复是调用该对象的equals方法
*/
//人类
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//复写equals
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
return false;
}
}
//main
class SingleTest {
public static void main(String[] args) {
ArrayList al = new ArrayList();
//添加数据
al.add(new Person("李四",12));
al.add(new Person("张三",12));
al.add(new Person("李四",12));
al.add(new Person("王武",30));
out(al);
al = singleElement(al);
System.out.println();
out(al);
}
//输出元素
public static void out(ArrayList arr) {
//迭代器
Iterator it = arr.iterator();
while(it.hasNext()) {
Object obj = it.next();
//因为存储时对象向上转型成Object,所以使用时,要向下转型
if (obj instanceof Person) {
Person p = (Person)obj;
out(p.getName() + "..." + p.getAge());
}
}
}
//去重(相同姓名,相同年龄视为同一个人)
public static ArrayList singleElement(ArrayList al) {
ArrayList a = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if (obj instanceof Person) {
Person p = (Person)obj;
if (!a.contains(p)) { //contains是调用该对象的equals方法,我们必须复写
a.add(p);
}
}
}
return a;
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例9:集合转成数组
例9:集合转成数组
import java.util.*;
/*
ArrayList转成数组
好处:限制对元素的操作,不需要增删
<T> T[] toArray(T[] a)
按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;
返回数组的运行时类型是指定数组的运行时类型。
结论:
1、制定的数组多长为恰当
当制定类型的数组长度小于集合size那么,该方法会在内部自动开辟一个
与该size相同的数组
当制定的数组长度大于集合的size时,就不开辟数组,
而是使用该数组,没有使用的位置为null,因为数组自动初始化
由此可以看看出制定的数组大小和size相同时,性能最优
*/
class ArrayListToArray
{
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<String>();
arr.add("java");
arr.add("fgava");
arr.add("jffa");
arr.add("aa");
String[] a = arr.toArray(new String[arr.size()]);
out(a);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
//输出
public static void out(String[] s) {
for(int i=0;i<s.length;i++) {
System.out.print(s[i] + " ");
}
}
}
例10:数组转成集合
import java.util.*;
/*
Collections.asList()方法实例
结论:
1、如果数组中的元素是对象,那么变成集合时,
数组中的元素直接转成集合中的元素
2、如果数组中的元素是基本类型,那么会将该数组作为
集合中的元素,即现在集合中存储的是一个数组
*/
class AsList
{
public static void main(String[] args) {
String[] arr1 = {"Java","gg","aa","cd"};
List<String> al = Arrays.asList(arr1);
out(al); //[Java, gg, aa, cd]
int[] nums = {1,5,7,3,8};
List<int[]> a2 = Arrays.asList(nums);
out(a2); //[[I@55f33675]
Integer[] n = {1,5,7,3,8};
List<Integer> a3 = Arrays.asList(n);
out(a3); //[1, 5, 7, 3, 8]
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例11:对集合的元素反转->reverseOrder
import java.util.*;
/*
static <T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
测试:
*/
//mian
class ReverseTest
{
public static void main(String[] args) {
reverseElement();
}
//元素反转
public static void reverseElement() {
//将StrLenComparator()比较器构造器反转
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("Java");
ts.add("c++");
ts.add("aaaff");
ts.add("c");
ts.add("ef");
ts.add("aa");
out(ts);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
//字符串长度排序比较器
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
int num = s1.length() - s2.length();
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
}
例12:将集合中一部分元素替换成制定元素->fill升级版
import java.util.*;
/*
fill方法测试
练习:将集合中一部分元素替换成制定元素
*/
//mina
class FillTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
selfFill(list, "ccc", 1, 4);
out(list);
}
//将集合中一部分元素替换成制定元素
public static void selfFill(ArrayList<String> list, String key, int start, int end) {
for (int i=start;i<end;i++) {
list.set(i, key);
}
}
//full方法测试
public static void fillTest() {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
Collections.fill(list, "Java");
out(list);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
例13:ArrayList元素去重
import java.util.*;
/*
去除ArrayList中的重复元素
Author:renpingqing
Date:2013年7月17日 17:57:04
*/
class ArrayListSingleElement {
public static void main(String[] args) {
ArrayList a = new ArrayList();
a.add("Java1");
a.add("Java2");
a.add("Java1");
a.add("Java3");
out(a);
a = SingleElement(a);
out(a);
}
//去重方法
public static ArrayList SingleElement(ArrayList arr) {
ArrayList al = new ArrayList();
Iterator it = arr.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (!al.contains(obj)) {
al.add(obj);
}
}
return al;
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}