java28：集合类2

增强for 循环

java 1.5 之后：

用于遍历集合和数组（简化了遍历集合和数组的操作）
for(ELEMENT_TYPE e : LIST_ARRAY){
}
新循环是使用迭代器的形式实现的不要通过集合删除元素

for(String str : list){
System.out.println(str);
list.remove(str);//报错不能删除

}

package day28;

import java.util.ArrayList;
import java.util.Collection;

public class Demo01 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
for (int i : arr) {
System.out.print(i + 1);
}

System.out.println();

for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + 1);

}

System.out.println();

Collection<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
list.add(9);
for (int i : list) {
System.out.print(i + 1);
}

}
}

List 集合的subList方法：
获取当前集合的子集
List subList(int start,int end)
对子集的修改会影响原集合

package day28;

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

public class Demo02 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
System.out.println(list);
//基本类型不能作为泛型
List<Integer> subList =list.subList(3,9);
System.out.println(subList);

//将子集的元素扩大10倍
for(int i = 0;i< subList.size();i++){
int sub = subList.get(i);
sub = sub*10;
subList.set(i,sub);
}
for(int i = 0;i<subList.size();i++){
subList.set(i,subList.get(i)*10);
}
System.out.println(subList);
System.out.println(list);
}
}

数据结构：
都是保存数据

队列Queue 用于存储一组数据，但是糴存取方式有一定的要求必须先进先出（FIFO（First Input First Output））不能从中间取出一个，so 没有什么查询

常用语子类实现LinkedList
队列的方法
add(E e)增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
boolean offer（E e）：向队列末尾追加一个元素 追加成功返回true如果队列已满，则返回false
E poll（） 从队首取出元素（取出后就从队列中删除了该元素）如果队列为空，则返回null
E peek（） 获取队首元素，但是不删除 如果队列为空，则返回null

remove移除并返回队列头部的元素如果队列为空，则抛出NoSuchElementException异常
element 返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞
队列的遍历是一次性的

只有取出队首的元素，才能获取队列中第二个元素

package day28;

import java.util.LinkedList;
import java.util.Queue;

public class Demo03 {
public static void main(String[] args){
Queue<String> queue = new LinkedList<String>();
queue.offer("A");
queue.offer("B");
queue.offer("C");
System.out.println(queue);

System.out.println(queue.peek());
String str = null;
while((str = queue.poll()) != null){
System.out.print(str);
}
}
}

栈

Deque是Queue的子接口

使用双端队列，只允许元素都一个方向进出， 栈结构，栈结构存取元素要本着先进后出（FILO）First Input Last Output

栈有良好的历史追溯性

LinkedList实现了Deque

package day28;

import java.util.Deque;
import java.util.LinkedList;

public class Demo04 {
public static void main(String[] args){
Deque<String> stack = new LinkedList<String>();//创建栈
stack.push("A");//向栈中"添加"元素
stack.push("B");
stack.push("C");
stack.push("D");
System.out.println(stack);//输出栈
System.out.println(stack.peek());//获取栈首元素，类似Queue
//System.out.println(stack.pop());//类似队列
while(stack.peek() != null){//遍历栈  要使用peek 判断栈首是否有元素，在调用pop方法来获取否侧会有异常
System.out.print(stack.pop());
}
}
}

集合排序
Comparable接口

在对数组或者集合元素进行排序时，首先确定比较大小，有了结论才可以进行排序，如何比较大小，需要实现这个接口，并实现七种的抽象方法来定义比较规则

Arrays 在对数组进行排序时，比较每个元素大小时就会调用这些元素的compareTo方法精心比较，而这个方法就是Comparable接口定义的

package day28;
//哪一个类实现这个接口就用这个类的作为泛型
public class Point implements Comparable<Point> {//实现这个接口 接口中有一个方法
private int x;
private int y;

public Point(int x,int y ){
this.x = x;
this.y = y;
}

@Override
public String toString(){
return x+","+y;
}

/**
* 返回值不在乎具体的值，只关心取值范围
* 	>0 当前对象比给定对象大
*  <0 当前对象比给定对象小
*  =0 当前对象和给定对象相等
*/
public int compareTo(Point p){//定义接口中方法 Point 实例之间的比较规则 这个方法 equals 有关联
/**
* 定义点之间的比较规则：
* 	点到原点的距离长的大
*/
int len = this.x * this.x + this.y*this.y;
int pLen = p.x* p.x +p.y*p.y;
return 	len - pLen;

}
/**
* compareTo 方法的返回值应该与equals 方法的返回值具有一致性
* 当两个对象的equals 方法返回true时
* compareTo方法应该返回0
*/

}

Collection 是集合的父接口

Collections 集合的工具类

其中有一个方法是sort 用于排序集合

java中的很多类都实现了Comparable 接口 String Integer等等
他们自身就已经定义了比较规则，但是不能满足排序的要求，就需要另外指定比较规则

Collections 提供了一个重载的排序方法
sort（Collection c, Comparator com）
比较器

Comparator 接口
比较器 用来定义比较规则

当待用Collections 的 sort（Collection c,Comparator com）方法时，该方法在排序集合时，不适用集合中元素自身的比较规则，而是使用我们提供的比较器中的比较规则尽心比较后再进行排序

package day28;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo06 {
public static void main(String[] args){
List<Point> list = new ArrayList<Point>();
list.add(new Point(3,4));
list.add(new Point(7,8));
list.add(new Point(9,0));
list.add(new Point(5,6));
list.add(new Point(1,2));
System.out.println(list);
Collections.sort(list);
System.out.println(list);//排序集合java.util.Collections

List<String> strList = new ArrayList<String>();
strList.add("fa");
strList.add("cd");
strList.add("ef");
strList.add("ab");
strList.add("de");
strList.add("bc");
System.out.println(strList);
Collections.sort(strList);
System.out.println(strList);

List<String> strList2 = new ArrayList<String>();
strList2.add("asdf");
strList2.add("xcb");
strList2.add("123 asfd ");
strList2.add("r2r234");
strList2.add("g cg");
strList2.add("asd sdf e");
strList2.add("asdf ");
System.out.println(strList2);
Collections.sort(strList2, new NewComparator());//使用自己定义的比较器 来排序
System.out.println(strList2);

List<String> strList3 = new ArrayList<String>();
strList3.add("asdf");
strList3.add("xcb");
strList3.add("123 asfd ");
strList3.add("r2r234");
strList3.add("g cg");
strList3.add("asd sdf e");
strList3.add("asdf ");
Comparator<String> comparator = new Comparator<String>(){//使用匿名内部类
public int compare(String s1,String s2){
return s1.length() - s2.length();
}
};
System.out.println(strList3);
Collections.sort(strList3,comparator);
System.out.println(strList3);
}
}

/**
* 一般都是用匿名内部类临时创建一个比较器
*/

class NewComparator implements Comparator<String>{//自定义比较器
/**
* 比较规则
* 当返回值 >0 s1 > s2
* 当返回值 <0 s1 < s2
* 当返回值 =0 s1 = s2
*/
public int compare(String s1,String s2){
return s1.length() - s2.length();
}
}

Set 集合
不重复集合

在Set集合中不存在两个元素equals 为true
Set 集合的重用实现类

HashSet：使用散列算法实现的Set

散列算法，大容量数据
hashCode()

TreeSet：使用二叉树实现的Set

package day28;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Demo07 {
public static void main(String[] args){
List<String> list = new ArrayList<String>();
Set<String> set = new HashSet<String>();//也支持泛型，和List 一样用来约束集合的类型
String str = "abc";
for(int i = 0;i<5;i++){
list.add(str);
set.add(str);
}
System.out.println(list);
System.out.println(list.size());
System.out.println(set);
System.out.println(set.size());//不重复集合
}
}

package day28;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class Demo08 {
public static void main(String[] args){
Set<Integer> set = new HashSet<Integer>();
Random r = new Random();
int count = 0;
while(set.size()<10){
count++;
set.add(r.nextInt(10));
}
System.out.println(set+"--"+count);
}

}

Set 集合是无序的 so 没有get方法

package day28;

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

public class Demo9 {
public static void main(String[] args){
Set<String> set = new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
set.add("5");
System.out.println(set);//Set 集合是无序的
}
}

Set 集合没有get 方法
so
只能通过迭代器的方式获取元素

package day28;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo09 {
public static void main(String[] args){
Set<String> set = new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
set.add("5");
System.out.println(set);//Set 集合是无序的
Iterator<String> it = set.iterator();
while(it.hasNext()){//迭代Set集合
String str = it.next();
System.out.print(str);
}
System.out.println();
for(String i:set){//迭代Set集合
System.out.print(i);
}
}
}

HashSet 存取元素需要依靠元素
hashCode() 方法的返回值 是在Object中定义的方法

重写方法要注意：与equals 方法一致=》当两个对象equals 方法比较为true时，hashCode()方法返回的数字应该相同

不同的对象hashCode()值要尽量避免相同=》重写hashCode() =》算法

package day28;

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

public class Demo10 {
public static void main(String[] args){
Set<Point> set = new HashSet<Point>();
Point p = new Point(1,1);
set.add(p);
System.out.println(set.size());

set.add(p);
System.out.println(set.size());
p.setX(2);
p.setY(2);
set.add(p);//修改了hashCode 是可以将用一个对象放入两次的
System.out.println(set.size());
}
}

本文出自 “浪漫的偷笑” 博客，转载请与作者联系！