持有对象
一. Arrays
1.基本概念
特点:大小固定
含义:数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量
举例:如何返回数组引用
public class Test {
private static Random rand = new Random(47);//Random用法
static final String[] FLAVORS = {
"A","B","C","D","E","F","G"
};
public static String[] flavorset(int n) {
String[] results = new String[n];//JAVA中数组初始化范围可以为变量
boolean picked[] = new boolean[FLAVORS.length];
for(int i = 0; i < n; i++) {
int t;
do
t = rand.nextInt(FLAVORS.length);//nextInt,Random的使用方法
while(picked[t]);//do while用法,记得加分号
results[i] = FLAVORS[t];
picked[t] = true;//false
}
return results;
}
public static void main(String[] args){
for(int i = 0; i < 7; i++) {
System.out.println(Arrays.toString(flavorset(3)));//数组的输出方法
}
}
}
2.数组中的比较:
数组之间的比较:
Arrays.equals(a1,a2)
,数组元素个数必须相等,并且对应位置的元素也相等。
数组元素之间的比较:
使用Comparable接口:
import java.util.Arrays;
public class ComType implements Comparable<ComType>{//继承Comparable接口
int i;
int j;
private static int count = 1;
public ComType(int n1, int n2) {//写构造器,接收外部参数
i = n1;
j = n2;
}
public String toString() {//如果有必要,重写toString方法
String result = "[i = " + i + ", j = " + j + "]";
if(count++ % 3 == 0)
result += "\n";
return result;
}
public int compareTo(ComType rv) {//重写compareTo方法
if(i < rv.i) return -1;
if(i > rv.i) return 1;
if(j < rv.j) return -1;
if(j > rv.j) return 1;
return 0;
}
public static void main(String[] argv) {//最后测试输出
ComType[] a = new ComType[6];//注意开6的数组,下面是0到5
a[0] = new ComType(2,3);a[1] = new ComType(2,5);a[2] = new ComType(4,7);
a[3] = new ComType(6,9);a[4] = new ComType(3,7);a[5] = new ComType(3,4);
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
使用Comparator接口:
两者不同之处:
Comparable接口将比较代码嵌入到需要进行比较的类的自身代码中,而Comparator接口在一个独立的类中实现比较。
import java.util.*;
class ComTypeComparator implements Comparator<ComType>{ //<>里面应该为要比较的元素类型
public int compare(ComType a, ComType b) {//方法必须是public的
if(a.i < b.i) return -1;
if(a.i > b.i) return 1;
if(a.j < b.j) return -1;
if(a.j > b.j) return 1;
return 0;
}
}
public class ComType {
int i;
int j;
static int count = 1;
public ComType(int i, int j) {
this.i = i;
this.j = j;
}
public String toString() {
String result = "[i = " + i + ", j = " + j + "]";
if(count++ % 3 == 0)
result += "\n";
return result;
}
public static void main(String[] argv) {
ComType[] a = new ComType[6];
a[0] = new ComType(2,3);a[1] = new ComType(2,5);a[2] = new ComType(4,7);
a[3] = new ComType(6,9);a[4] = new ComType(3,7);a[5] = new ComType(3,4);
Arrays.sort(a, new ComTypeComparator());
System.out.println(Arrays.toString(a));
}
}
3.数组的复制和查找:
Arrays.binarySearch
使用之前必须将元素排好序。如果数组中有重复的元素,不确定返回的是哪一个元素的位置。
如果使用Comparator
排序了数组,那么在使用binarySearch
时必须提供同样的Comparator
。
基本类型数组和对象数组都可以复制,如果只复制对象数组,只是复制了对象的引用,而不是对象本身的拷贝。这被称为“浅复制”。
import java.util.Arrays;
public class ComType{
public static void main(String[] argv) {
Integer[] a = new Integer[5];
Arrays.fill(a, 3);
a[2] = 9;
Integer[] b = new Integer[10];
Arrays.fill(b, 23);
System.arraycopy(a, 0, b, 0, a.length);
b[0] = 1;
Arrays.sort(b);
System.out.println(Arrays.toString(b));
System.out.println(Arrays.binarySearch(b,9));
}
}
二. 容器类
1.数组与容器的区别:
数组只能保存特定类型。
容器类只能保存对象的引用。而数组可以创建为直接保存基本类型,也可以保存对象的引用。2.
2.容器类简介:
Collection:一个独立元素的序列,这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素,而Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序。
如果在列表中频繁插入和删除LinkedList更合适,否则ArrayList效率更高。HashSet提供最快的查询速度,TreeSet使元素处于排序状态。
Map:一组成对的“键值对”对象,允许用键来查找值。TreeMap按照比较结果的升序保存键。LinkedHashMap按照插入顺序保存键。
import java.util.*;
public class Test{
static Collection<String> fill(Collection<String> c){
c.add("dog");
c.add("cat");
c.add("dog");
return c;
}
static Map<String, String> fill(Map<String, String> c){
c.put("dog", "Bosco");
c.put("dog", "Spot");
c.put("cat", "Rags");
return c;
}
public static void main(String[] argv) {
System.out.println(fill(new LinkedList<String>()));
System.out.println(fill(new ArrayList<String>()));
System.out.println(fill(new HashSet<String>()));
System.out.println(fill(new TreeSet<String>()));
System.out.println(fill(new HashMap<String, String>()));
System.out.println(fill(new TreeMap<String, String>()));
System.out.println(fill(new LinkedHashMap<String, String>()));
}
}
输出结果为:
[dog, cat, dog]
[dog, cat, dog]
[cat, dog]//Set去掉了重复元素
[cat, dog]
{cat=Rags, dog=Spot}//注意键值对的写法
{cat=Rags, dog=Spot}
{dog=Spot, cat=Rags}
3.添加一组元素的方法:
Arrays.asList()
接受一个数组或是一个用逗号分隔的元素列表。转换后的List对象是一个size不能改变的对象。如果对该对象做增加或删除操作,将会报不支持的异常。
Collection<Integer> a = new ArrayList<Integer>(Array.asList(1, 2, 3, 4));
a.addAll()
成员方法只能接受另一个Collection对象作为参数。
Collections.addAll()
方法可以支持可变参数列表。例如:
Collections.addAll(collection, 11, 12, 14);
4.List用法:
import java.util.*;
public class Test{
public static void main(String[] argv) {
List<Integer> a = new ArrayList<Integer>();
Collections.addAll(a, 1, 2, 3, 67, 34, 19);
System.out.println(a);
a.remove(3);//删去值为3的元素
System.out.println(a);
System.out.println(a.indexOf(1));//查找元素所在的索引
System.out.println(a.subList(1, 3));//获得下标为1和2的两个元素
System.out.println(a.containsAll(a.subList(1,3)));
System.out.println(a.get(2));//通过索引查找元素
a.removeAll(a.subList(2, 3));//删去第2个元素
System.out.println(a.isEmpty());
a.clear();
System.out.println(a.isEmpty());
}
}
LinkedList中removeLast()
方法移除并返回列表中的最后一个元素。addFirst()
方法将元素插到列表端部,addLast()
方法将元素插到列表尾部。
5.迭代器
迭代器是一个对象,它的工作是遍历并选择序列中的对象,而不必关心序列底层的结构。
迭代器只能单向移动。
import java.util.*;
public class Test{
public static void main(String[] argv) {
List<Integer> a = new ArrayList<Integer>();
Collections.addAll(a, 1, 2, 3, 67, 34, 19);
Iterator<Integer> it = a.iterator();//记住迭代器的写法
while(it.hasNext()) {//it.hasNext()
System.out.println(it.next());//it.next()
it.remove();//it.remove()
//如果要达到每个元素都删除的效果,必须先调用it.next(),再调用it.remove()
}
System.out.println(a);
}
}
迭代器更多用于方法的参数中:
public static void display(Iterator<Pet> it)
这样对于Pet类型构成的任何容器类,都可以实现遍历。
6.Foreach语句:
Foreach简化了迭代器。
for( 元素类型 变量名 :Collection集合 & 数组 )
for(Integer b: a) {
System.out.println(b);
}