标签:ring http aix 现象 compare 一个人 操作 java rom
为什么要有集合
面向对象语言对事物的体现都是以对象的形式体现,所以为了方便对多个对象的操作,就是对对象进行存储,集合就是存储对象最常用的一个方式。
数组的长度是固定的,而集合的长度是可变的。
数组可以存储基本数据类型,而集合只能存储对象。
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
框架(framework)是一个类的集,它奠定了创建高级功能的基础。框架包含很多超类,这些超类拥有非常有用的功能、策略和机制。框架使用者创建的子类可以扩展超类的功能,而不必重新创建这些基本的机制。
他是所有集合的共性接口类
常用的方法有
1、添加
boolean |
add(E e) 确保此 collection 包含指定的元素(可选操作)。 |
boolean |
addAll(Collection<? extendsE> c) 将指定 collection 中的所有元素都添加到此 collection 中(可选操作)。 |
2、删除
boolean |
remove(Object o) 从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。 |
boolean |
removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。 |
3、判断
boolean |
contains(Object o) 如果此 collection 包含指定的元素,则返回 true。 |
boolean |
containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素,则返回 true。 |
boolean |
isEmpty() 如果此 collection 不包含元素,则返回 true。 |
4、获取
int |
size() 返回此 collection 中的元素数。 |
Iterator<E> |
iterator() 返回在此 collection 的元素上进行迭代的迭代器。 |
5、其他
Object[] |
toArray() 返回包含此 collection 中所有元素的数组。 |
<T> T[] | toArray(T[] a) 返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。 |
boolean |
retainAll(Collection<?> c) 仅保留此 collection 中那些也包含在指定 collection 的元素(可选操作)。取2个集合中的元素交集 |
List
有序:存入和取出的循序一直。
可以存储重复对象。
添加或删除元素,其后面的元素后往后移动一位置或向前移动一位置。
元素都有索引
常用方法:
void |
add(int index,E element) 在列表的指定位置插入指定元素(可选操作)。 |
E |
remove(int index) 移除列表中指定位置的元素(可选操作)。(返回被删除的对象) |
E |
set(int index,E element) 用指定元素替换列表中指定位置的元素(可选操作)。(返回被修改的对象) |
E |
get(int index) 返回列表中指定位置的元素。 |
int |
indexOf(Object o) 返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。 |
int |
lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。 |
List<E> |
subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。(左闭右开) |
List实际项目中常用的实现类
Vector:内部是数组数据结构,是同步的。(都不用了),增删查询都很慢。
ArrayList:内部是数组数据结构,是不同步的。(替代Vector的),查找元素的速度很快,增删慢。(因为存储的空间是连续的,所以查起来很快)。
LinkedList:内部是链表数据结构,是不同步的。增删元素速度很快,查询速度慢。
集合为什么大多都不同步?因为效率高。
Set
可以有序,可以无序,一般情况无序
不可以存储重复对象
元素没有索引,只能通过迭代器获取对象
循环数组是一个有界集合,即容量有限。如果程序中要收集的对象数量没有上限,就最好使用链表来实现。
Iterator(迭代器)接口
集合中的iterator()方法返回一个实现了Iterator接口的实例对象,可以用这个迭代器对象,依次访问集合中的元素。
Iterator接口中只有三种方法
如果达到了集合的末尾,next()方法将抛出NoSuchElementException异常。因此,在每次调用next()方法前都要做一下hasNext()的判断。
例如:
Collection<String> c = ...;
Iterator<String> iter = c.iterator();//获得c集合的迭代器
while(iter.hasNext()){
String element = iter.next();
System.out.print(element);
}
JDK1.5的新特性for each循环,它可以与任何实现了Iterable(迭代)接口的对象一起工作。其中只有一个方法Iterator<E> iterator();
next()方法
迭代器可以理解为是位于2个之间的,当调用next()方法的时候,迭代器向前移动一个位置,并返回刚刚越过的那个元素的引用。如图所示:
删除元素(remove()方法)和添加元素(add()方法)
Iterator接口的remove()方法将会删除上次调用next()方法时,返回的那个元素。示例代码如下:
package paly;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class WorkerTest {
public static void main(String[] args) {
LinkedList<String> ll1 = new LinkedList<String>();
Iterator<String> ll1Iterator = ll1.iterator();//Iterator没有add方法
System.out.println(ll1Iterator.hasNext());//返回false
ListIterator<String> listIterator = (ListIterator<String>) ll1.iterator();
// ll1Iterator.next();//报错
listIterator.add("zhangfan1");//向ll1集合中添加东西
listIterator.add("zhangfan2");//向ll1集合中添加东西
listIterator.add("zhangfan3");//向ll1集合中添加东西
listIterator.add("zhangfan4");//向ll1集合中添加东西
listIterator.add("zhangfan5");//向ll1集合中添加东西
myIterator(ll1);
// System.out.println(listIterator.hasNext());//迭代器里面没有东西
// listIterator.remove();//这里报错
// ll1Iterator.remove();//这里报错,估计要重新再次获得迭代器吧
// ll1Iterator.next();
listIterator = ll1.listIterator();//重新获得迭代器
System.out.println("将迭代器想右移动一位置:"+listIterator.next());//------位置一
listIterator.remove();//结果zhangfan1被删除了------位置二
// listIterator.remove();//这里报错,因为迭代器,在位置二的时候,已经把它越过的前一元素给删除了,现在这里没有元素,所以不能删除
// 现在删除zhangfan3
// 由于在位置一的时候迭代器向后越过了一位置,返回的是zhangfan1,而zhangfan1在位置二的时候被删除,现在要删除zhangfan3就要在向后越过2元素
myIterator(ll1);
listIterator.next();
listIterator.next();
listIterator.remove();//删除zhangfan3
System.out.println("删除zhangfan3以后");
myIterator(ll1);
}
public static void myIterator(Iterable a){//Collection
Iterator<String> temp = a.iterator();
while (temp.hasNext()) {
System.out.println(temp.next());
}
}
}
运行结果:
false
zhangfan1
zhangfan2
zhangfan3
zhangfan4
zhangfan5
将迭代器想右移动一位置:zhangfan1
zhangfan2
zhangfan3
zhangfan4
zhangfan5
删除zhangfan3以后
zhangfan2
zhangfan4
zhangfan5
static <T> int |
binarySearch(List<? extendsComparable<? super T>> list, T key) 使用二分搜索法搜索指定列表,以获得指定对象。 |
1、返回int,如果有要找的key就返回,key所在的位置。
2、返回int,如果没有要找的key就返回负数,并带添加次key值的插入点,并且插入进去后,数组还是拍好序列的,里面是-min-1,所以用得到的负数+1,取正就是插入点的索引
static <T> int |
binarySearch(List<? extends T> list, T key,Comparator<? super T> c) 使用二分搜索法搜索指定列表,以获得指定对象。 |
1、根据自定义比较器,进行比较,Comparator是一个接口,其中的比较方法要程序员自己实现。
static <T> List<T> |
asList(T... a) 返回一个受指定数组支持的固定大小的列表。 |
链表(相关类:List、LinkedList<E>、Iterator<E>、ListIterator<E>、Iterable<T>)
在数组和数组列表中,有很大的一个缺陷,就是每次添加非队列末尾的一个元素时,其后面的元素都要向后移一位置,或每次删除非队列末尾的一个元素时,其后面的元素都要向前移动一个位置。这就是其添加和删除的效率不高。而链表很好的解决了这一问题。
在Java程序设计语言中,所有链表实际上都是双向链接的。即每个结点还存放着指向前驱结点的引用。如下图所示:
删除一个元素:
链表和泛型集合的重要区别是:链表是一个有序集合。
LinkedList<E>的add()方法是将元素添加到集合的末尾,但常常要添加到其他元素的中间,用Iterator<E>接口的子接口ListIterator<E>实现添加的功能,还可以向前查询元素
示例代码:
package paly;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class WorkerTest {
public static void main(String[] args) {
LinkedList<String> ll1 = new LinkedList<String>();
Iterator<String> ll1Iterator = ll1.iterator();//Iterator没有add方法
System.out.println(ll1Iterator.hasNext());//返回false
ListIterator<String> listIterator = (ListIterator<String>) ll1.iterator();
// ll1Iterator.next();//报错
listIterator.add("zhangfan1");//向ll1集合中添加东西
listIterator.add("zhangfan2");//向ll1集合中添加东西
listIterator.add("zhangfan3");//向ll1集合中添加东西
listIterator.add("zhangfan4");//向ll1集合中添加东西
listIterator.add("zhangfan5");//向ll1集合中添加东西
ll1.add("zhangfan6");//调用的是LinkedList的add方法,那它还在zhangfan5的后面
System.out.println("----------------添加zhangfan6");
myIterator(ll1);
// 现在在zhangfan4和zhangfan5之间添加3个元素看看效果
listIterator =ll1.listIterator();//重新获得迭代器
System.out.println("-------------迭代器刚刚越过的元素:"+listIterator.next());//不知道迭代器现在的位置在哪,打印出来看看
listIterator.next();//越过zhangfan2
listIterator.next();//越过zhangfan3
listIterator.next();//越过zhangfan4,现在迭代器在zhangfan4和zhangfan5之间
listIterator.add("zhangfan7");
listIterator.add("zhangfan8");
listIterator.add("zhangfan9");
myIterator(ll1);
System.out.println("--------------向前查询元素:"+listIterator.previous()+"下一个index:"+listIterator.nextIndex());
System.out.println("--------------向前查询元素:"+listIterator.previous()+"前一个index:"+listIterator.previousIndex());
System.out.println("--------------向前查询元素:"+listIterator.previous()+"前一个index:"+listIterator.previousIndex());
System.out.println("--------------向前查询元素:"+listIterator.previous()+"前一个index:"+listIterator.previousIndex());
}
public static void myIterator(Iterable a){//Collection
Iterator<String> temp = a.iterator();
while (temp.hasNext()) {
System.out.println(temp.next());
}
}
}
LinkedList也提供了get(int i)方法来查询元素,但是效率极其低下。
面试题:10、 有100个人围成一个圈,从1开始报数,报到14的这个人就要退出。然后其他人重新开始,从1报数,到14退出。问:最后剩下的是100人中的第几个人?
package paly;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
/**
* 10、 有100个人围成一个圈,从1开始报数,报到14的这个人就要退出。然后其他人重新开始,
* 从1报数,到14退出。问:最后剩下的是100人中的第几个人?
*
* @author Terry
* @date 2014-6-9
*
*/
public class Test10 {
static int howPoeple = 5674;
int indexRecord = 0;//索引记录
static final List<People> circlePeople = new ArrayList<People>();//圆圈
static LinkedList<People> linkedList = new LinkedList<People>();
/**
* @param args
*/
public static void main(String[] args) {
//看了运行结果,感觉不对,先做其他的,然后回来用面向对象的方式对比看看
begin(346);
counOffByLinkedList(howPoeple,346);
System.out.println("最后剩下"+howPoeple+"人中的第"+linkedList.getFirst().getNumber()+"人");
}
/**
* 测试重新获得迭代器,迭代器位置会变成第一个不,结果会还原
*/
public static void test(){
for (int i = 0; i < 5; i++) {
People people = new People();
people.setNumber(i);
linkedList.add(people);
}
ListIterator<People> li = linkedList.listIterator();
System.out.println(li.hasNext());
for (int i = 0; i < 5; i++) {
System.out.println(li.next().getNumber());
}
li = linkedList.listIterator();
System.out.println("------"+li.next().getNumber());
}
/**
* 用LinkedList来实现
* @param size:有多少人
* @param index:第几个人开始报数
*/
public static void counOffByLinkedList(int size,int index){
for (int i = 1; i < size+1;i++) {
People people = new People();
people.setNumber(i);
linkedList.add(people);
}
beginCountin(linkedList,index);
}
/**
* 开始报数方法
* @param index,第几个人开始报数
*/
public static void beginCountin(List list,int index){
ListIterator<People> listIterator = list.listIterator(index);
beginCountin(listIterator);
}
public static void beginCountin(ListIterator listIterator ){
/**
* 报数1-14
*/
for (int i = 0; i < 14; i++) {
if(listIterator.hasNext()){
listIterator.next();//报数
}else{
listIterator = linkedList.listIterator();//重新迭代
if(listIterator.hasNext()){
listIterator.next();//报数
}
}
}
if(linkedList.size()>2){
listIterator.remove();
beginCountin(listIterator);
}
if(linkedList.size()>1){
listIterator.remove();
}
}
/**
* 人们开始报数,每报到14,报到14的那个人退出,其他人继续报数
* @param index 取值 index>=0 index<howPoeple,位置index的人第一个报数
*/
public static void countOff(int index){
List<People> people = Test10.circlePeople;
if(people.size()==3){//这里是给debug用的,用来快速到达错误的地方
System.out.println();
}
for (int i = 0; i < 14; i++) {
if(index==people.size()){//index = poeples.size()-1,表示数组中的最后一个人了,index==poeples.size()
// 表示应该是最后一个人的下一个人,也就是返回到第一个人了
index = 0;//又从第一个人开始
}
// People temp = poeples.get(index);//这个人报数,喊完过后,后一个位置的人报数。辅助思考用的
if(i == 13){//代表着要退出一个人了,从1开始报数报,这是第14次报数,前面==13因为索引是从0开始的
if(people.size()>2){//圈里的人数有3人以上
/**
* 代表着数组中的第一个人要退出,然后他后面的人和最后一个人牵手,
* 最后一个人的右边是第二个人,第二个人的左边是最后一个人
*/
if(index == 0){
if(people.size() == 1){//如果圈里面只剩下一个人就不退出了
break;
}
People me = people.get(index);//要退出的人
People lastPeople = people.get(people.size()-1);
People afterMe = people.get(index + 1);
lastPeople.setRightPeople(afterMe);
afterMe.setLeftPeople(lastPeople);
people.remove(me);
System.out.println(people.size()+"::index="+index);
countOff(index);//这里本想index++;的,但是ArrayList元素删除的时候,被删元素的后面元素都会向前移一个位置
}
/**
* 代表着数组中的最后一个人要退出,然后他前面的人和第一个人牵手,
* 第一个人的左边是他前面的人,他前面的人的右边是第一个人
*/
if(index == people.size()-1){
if(people.size() == 1){//如果圈里面只剩下一个人就不退出了
break;
}
People me = people.get(index);//要退出的人
People firstPeople = people.get(0);
People beforeMe = people.get(people.size()-1-1);
firstPeople.setLeftPeople(beforeMe);
beforeMe.setRightPeople(firstPeople);
people.remove(me);
index = 0;//最后一个元素都移除了,他后面没有元素了,所以要从0开始
System.out.println(people.size()+"::index="+index);
countOff(index);
}
//做到这里发现,单独people对其中的左右people交换的时候,可以封装成一个方法,那代码量将会少很多
if(people.size() == 1){//如果圈里面只剩下一个人就不退出了
break;
}
People me = people.get(index);//要退出的人
People afterMe = people.get(index + 1);
People beforeMe = people.get(index - 1);
afterMe.setLeftPeople(beforeMe);
beforeMe.setRightPeople(afterMe);
people.remove(me);
System.out.println(people.size()+"::index="+index);
countOff(index);
}else{
people.remove(index);
}
}
index ++;//每报一次数,数组索引往后移一位置
}
}
/**
* 第一个人和其他2人牵手的方式
* 第一个人和其他2人牵手,他的左边是最后一个人,他的右边是第二个人
*/
public static void fasePeople(int i){//为了方便,这里用static好了,多花点内存,就多花点了,不管那么多了
List<People> temp = Test10.circlePeople;
// if(i == 0){
People me = temp.get(i);
People leftPeople = temp.get(temp.size()-1);
People rightPeople = temp.get(i+1);
me.setLeftPeople(leftPeople);
me.setRightPeople(rightPeople);
// }
}
/**
* 最后一个人和其他2人牵手的方式
* 最后一个人和其他2人牵手,他的左边是倒数第二的人,他的右边是第一个人
*/
public static void lastPeople(int i){
List<People> temp = Test10.circlePeople;
// if(i == temp.size()-1){
People me = temp.get(i);
People leftPeople = temp.get(i-1);
People rightPeople = temp.get(0);
me.setLeftPeople(leftPeople);
me.setRightPeople(rightPeople);
// }
}
/**
* 第二个人和第二个以后的人和其他2个人牵手,他的左边是他前面的那个人,他的右边是他后面的那个人
*/
public static void secondAndOtherPeople(int i){
List<People> temp = Test10.circlePeople;
People me = temp.get(i);
People leftPeople = temp.get(i-1);
People rightPeople = temp.get(i+1);
me.setLeftPeople(leftPeople);
me.setRightPeople(rightPeople);
}
/**
* 开始
* @param index,0-howPoeple之间
*/
public static void begin(int index){
Test10 test10 = new Test10();
// TODO Auto-generated method stub
//howPoeple个人站在一起//这里可以用享元模式
for (int i = 1; i < test10.howPoeple+1; i++) {
People people = new People();
people.setNumber(i);
test10.circlePeople.add(people);
}
//howPoeple个人手拉手围成一个圆圈
for (int i = 0; i < test10.howPoeple; i++) {
// 第一个人和其他2人牵手,他的左边是最后一个人,他的右边是第二个人
if(i == 0){
fasePeople(i);
continue;
}
// 最后一个人和其他2人牵手,他的左边是倒数第二的人,他的右边是第一个人
if(i == circlePeople.size()-1){
lastPeople(i);
continue;
}
// 第二个人和第二个以后的人和其他2个人牵手,他的左边是他前面的那个人,他的右边是他后面的那个人
secondAndOtherPeople(i);
}
countOff(index);
System.out.println("最后剩下"+howPoeple+"人中的第"+Test10.circlePeople.get(0).getNumber()+"人");
}
}
class People{
private int number;//自己的编号
private People leftPeople;//左边的人
private People rightPeople;//右边的人
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public People getLeftPeople() {
return leftPeople;
}
public void setLeftPeople(People leftPeople) {
this.leftPeople = leftPeople;
}
public People getRightPeople() {
return rightPeople;
}
public void setRightPeople(People rightPeople) {
this.rightPeople = rightPeople;
}
}
散列表hash table,可以快速地查找所需要的对象。散列表为每个对象计算一个整数,称为散列码(hash code).
hashcode的作用:
首先,想要明白hashCode的作用,你必须要先知道Java中的集合。
总的来说,Java中的集合(Collection)有两类,一类是List,再有一类是Set。
前者集合内的元素是有序的,元素可以重复;后者元素无序,但元素不可重复。
那么这里就有一个比较严重的问题了:要想保证元素不重复,可两个元素是否重复应该依据什么来判断呢?
这就是Object.equals方法了。但是,如果每增加一个元素就检查一次,那么当元素很多时,后添加到集合中的元素比较的次数就非常多了。
也就是说,如果集合中现在已经有1000个元素,那么第1001个元素加入集合时,它就要调用1000次equals方法。这显然会大大降低效率。
于是,Java采用了哈希表的原理。哈希(Hash)实际上是个人名,由于他提出一哈希算法的概念,所以就以他的名字命名了。
哈希算法也称为散列算法,是将数据依特定算法直接指定到一个地址上。
初学者可以这样理解,hashCode方法实际上返回的就是对象存储的物理地址(实际可能并不是)。
这样一来,当集合要添加新的元素时,先调用这个元素的hashCode方法,就一下子能定位到它应该放置的物理位置上。
如果这个位置上没有元素,它就可以直接存储在这个位置上,不用再进行任何比较了;如果这个位置上已经有元素了,
就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散列其它的地址。
所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了,几乎只需要一两次。
所以,Java对于eqauls方法和hashCode方法是这样规定的:
1、如果两个对象相同,那么它们的hashCode值一定要相同;
2、如果两个对象的hashCode相同,它们并不一定相同,上面说的对象相同指的是用eqauls方法比较。
当然可以不按要求去做了,但会发现,相同的对象可以出现在Set集合中。同时,增加新元素的效率会大大下降。
示例代码:
String a = new String("BBC");
String b = "bbc";
String c = new String();
String d = "bbc";
System.out.println(a.hashCode());
System.out.println(b.hashCode());
System.out.println(c.hashCode());
System.out.println(d.hashCode());
运行输出:
65539
97315
0
97315
在Java中,散列表用链表数组实现。每个列表被称为桶。想要查找表中对象的位置,就要先计算它的散列码,然后与桶的总数取余,所得到的结果就是保存这个元素的桶的索引。例如:
如果某个对象的散列码为76268,并且有128个桶,对象应该保存在第108号桶中(76268%128=108)。或许会很幸运,在这个桶中没有其他元素,此时将元素直接插入到桶中就可以了。当然,有时候会遇到桶被占满的情况,这也是不可能避免的。这种现象被称为散列冲突。这时,需要用新对象与捅中的所有对象进行比较,查看这个对象是否已经存在。
TreeSet类是一个有序不重复集合,它每次添加元素的时候都会进行比较,然后再按顺序添加,所以添加的速度很慢。它的底层数据结构是二叉树。
它有2中排序的方式:一种是,添加的元素自身可以排序,实现了Comparable
另一种是,你给TreeSet定义一个比较器(Comparator),TreeSet根据Comparatro的
int |
compare(T o1,T o2) 比较用来排序的两个参数。 |
来进行比较。当两种排序都存在是优先用给定的比较器进行比较。
示例代码:
SortedSet<String> sorter = new TreeSet<String>();
sorter.add("dbc");
sorter.add("BBC");
sorter.add("bbc");
sorter.add("cbc");
sorter.add("abc");
for (String string : sorter) {
System.out.println(string);
}
运行结果:
BBC
abc
bbc
cbc
dbc
TreeSet(Comparator<? super E> comparator)
boolean addAll();
标签:ring http aix 现象 compare 一个人 操作 java rom
原文地址:http://www.cnblogs.com/ipetergo/p/6219069.html