黑马程序员————集合类

------Java培训Android培训iOS培训.Net培训、期待与您交流!-------


一、集合类

 

1.为什么出现集合类?

面向对象的语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行捕捉,集合就是对象常用的存储方式。

 

2数组合集合类的区别。

数组的长度是固定的,集合的长度是可变的。

数组中可以存储基本数据类型,集合只能存储对象。

 

3.特点

1)用于存储对象

2)长度是可变的

3)不能存储基本数据类型

 

二、集合框架

 

1.一些基本的概念和方法

集合容器因为内部的数据结构不能,有多重具体的容器,不断的向上抽取,就形成了集合框架。

 

框架的顶层就是collection是接口

 


Collection的常见方法:1.增,2.删,3.改,4.查

 

1,添加。

boolean add(Object obj):

boolean addAll(Collection coll):


2,删除。

boolean remove(object obj):

boolean removeAll(Collection coll);

void clear();


3,判断:

boolean contains(object obj):

boolean containsAll(Colllection coll);

boolean isEmpty():判断集合中是否有元素。 

 

4,获取:

int size():

Iterator iterator():取出元素的方式:迭代器。

该对象必须依赖于具体容器,因为每一个容器的数据结构都不同。

所以该迭代器对象是在容器中进行内部实现的。

对于使用容器者而言,具体的实现不重要,只要通过容器获取到该实现的迭代器的对象即可,

也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

其实就是抓娃娃游戏机中的夹子!

5,其他:

boolean retainAll(Collection coll);取交集。

Object[] toArray():将集合转成数组。

 

import java.util.ArrayList;
import java.util.Collection;
 
public class CollectionDemo {
 
/**
 * @param args
 */
public static void main(String[] args) {
Collection col1 = new ArrayList();
Collection col2 = new ArrayList();
show(col1,col2);
}
public static void show(Collection col1, Collection col2) {
//1.添加元素
col1.add("abc1");
col1.add("abc2");
col1.add("abc3");
col1.add("abc4");
col2.add("abc2");
col2.add("nba2");
col2.add("nba3");
//1.2添加集合
col1.addAll(col2);
//2.删除元素
//col1.remove("abc1");  //会改变集合的长度
System.out.println(col1);
//2.1删除集合
//col1.removeAll(col2);
//System.out.println(col1);
//3.判断
boolean b = col1.contains("abc2");
boolean b1 = col1.contains("abc1");
//System.out.println(b);
//System.out.println(b1);
//3.1.判断是否包含集合
boolean b3 = col1.containsAll(col2);
//System.out.println(b3);
//4.获取
int len = col1.size();//获取集合的长度
//System.out.println(len);
//5.其他
boolean b4 = col1.retainAll(col2);//取交集,保留和指定的集合(col2)相同的元素,而删除不同的元素,
//即删除col1中的和col2不同的元素。
System.out.println(b4);
System.out.println(col1);
//清空集合
col1.clear();	//清空集合col1
System.out.println(col1);
}
}


2.迭代器的使用

迭代器就就是取出元素的方式

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class IteratorDemo {
 
/**
 * @param args
 */
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//使用了Collection中的iterator()方法。 调用集合中的迭代器方法,是为了获取集合中的迭代器对象。
Iterator it = coll.iterator();	//获取迭代的对象
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println(it.next());//NoSuchElementException 
}
 
}

 it.next()返回的类型是Object,取出集合的第一个元素,然后内部有一个指针指向下一个元素,如果结合没有元素,会出现java.util.NoSuchElementException 异常,因为集合没有元素了。

 

三、List集合

 

有序的(存入和取出的顺序一致),元素都有索引(角标),元素可以重复使用。

 

1.常见的方法

 

1),添加

void add(index,element);

void add(index,collection);

 

2),删除;

Object remove(index):


3),修改:

Object set(index,element);


4),获取

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(from,to);

 

Object[] toArray() :返回按适当顺序包含列表中的所有元素的数组(从第一个元素到最后一个元素)。

常用方法的演示:

import java.util.ArrayList;
import java.util.List;
 
public class ListDemo {
 
/**
 * @param args
 */
public static void main(String[] args) {
List list = new ArrayList();
show(list);
}
public static void show(List list) {
list.add("abc1");
list.add("abc2");
list.add("abc3");
//System.out.println(list);
//1.指定位置添加元素
list.add(1, "nba");  //在集合1位置添加元素"nba"
//System.out.println(list);
//2.删除
list.remove(3);//删除角标3元素
//System.out.println(list);
//3.修改
list.set(1, "cba");//将1角标元素替换成"cba"
System.out.println(list);
//4.获取
System.out.println("get:"+list.get(2));//获取角标2的元素
System.out.println("sunlist:"+list.subList(0, 2));//获取0-2角标集合,不包含角标2
}
}
 


2.特有的取出方式


for(int x = 0;x<list.size();x++){
System.out.println(list.get(x));
}

补充1:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorDemo {
 
/**
 * @param args
 */
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2"))
list.add("nba");
else
System.out.println("next:"+obj);
}
System.out.println(list);
}
 
}
 

这个程序会出现java.util.ConcurrentModificationException 异常因为开始是迭代器在操作元素,后有出现集合操作元素即添加元素,迭代器和集合交替使用,集合操作改变集合的长度。


避免代码:

ListIterator it = list.listIterator();//获取迭代器对象,它可以实现//在迭代过程中对元素的增,删,该,查,只有list集合具备这个功能
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2"))
it.add("cba");
}

补充2:逆向取元素

while(lit.hasPrevious()){
System.out.println(lit.previous());
}

3.常见list子类的特点

|--Vector:内部是数组数据结构,是同步的。增删,查询都很慢!

|--ArrayList:内部是数组数据结构,是不同步的。替代了Vector。查询的速度快。

|--LinkedList:内部是链表数据结构,是不同步的。增删元素的速度很快。


1)Vectoor

hasMoreElements() 测试此枚举是否包含更多的元素。

nextElement() 如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素

public static void main(String[] args) {
Vector v = new Vector();
v.add("abc1");
v.add("abc2");
v.add("abc3");
Enumeration en = v.elements();
//Enumeration接口的功能与 Iterator 接口的功能是重复的
while(en.hasMoreElements()){
System.out.println("nextElement:"+en.nextElement());
}

被ArrayList替代了。

 

2)LinkedList

 

特有方法:

1.添加:

void addFirst()

void addLast()

jdk1.6

boolean offerFirst();

boolean offetLast();

 

2.获取

Object getFirst()

Object getLast()

jdk1.6

Object peekFirst();//获取但不移除,如果链表为空,返回null.

Object peekLast():

 

Object removeFirst()

Object removeLast()

jdk1.6

Objec pollFirst();//获取并移除,如果链表为空,返回null.

Objec pollLast();

public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
//System.out.println(link.getFirst());//获取第一个元素但是不会删除
//System.out.println(link.removeFirst());//获取元素但是会删除
System.out.println(link);
while(!link.isEmpty()){
System.out.println(link.removeLast());
}
System.out.println(link);
}


例子:

模拟堆栈或者队列数据结构

堆栈:先进后出

队列:先进后出

我们应该描述这样的一个容器,给使用者提供一个容器对象完成这两种结构的一种

//模拟队列先进先出的对象

import java.util.LinkedList;
public class DuiLie {
private LinkedList link;
 
public DuiLie() {
link = new LinkedList();
}
public void myAdd(Object obj){
//往后添加元素
link.addLast(obj);
}
public Object myGet(){
//取第一个元素,并修改集合的长度
return link.removeFirst();
}
public boolean Null(){
return link.isEmpty();
}
}
public class DuiLieDemo {
 
/**
 * @param args
 */
public static void main(String[] args) {
DuiLie d = new DuiLie();
d.myAdd("abc1");
d.myAdd("abc2");
d.myAdd("abc3");
d.myAdd("abc4");
while(!d.Null()){
System.out.println(d.myGet());
}
}
}


用jdk1.5

/*public boolean myAdd(Object obj){

//往后添加元素

return link.offerLast(obj);

}

public Object myGet(){

//取第一个元素

return link.pollFirst();

}*/

 

3)ArrayList

 

自定义对象

import java.util.ArrayList;
import java.util.Iterator;
public class Person {
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 int getAge() {
return age;
}
}
public class ArrayListDemo {
/**
 * @param args
 */
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("zhangsan",21));
al.add(new Person("lisi",18));
al.add(new Person("wangwu",16));
al.add(new Person("zhaoliu",28));
al.add(new Person("zhaoliu",28));
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person) it.next();//it.next()返回的是Object,需要强转
System.out.println(p.getName()+":"+p.getAge());
}
}
}

四、Set集合

 

无序的,元素是不可重复的。

方法和collection一样

 

子类:

1.HashSet: 内部数据结构是哈希表 ,是不同步的。

 

如何保证该集合的元素唯一性呢?

是通过对象的hashCode和equals方法来完成对象唯一性的。

如果对象的hashCode值不同,那么不用判断equals方法,就直接存储到哈希表中。 

如果对象的hashCode值相同,那么要再次判断对象的equals方法是否为true。

如果为true,视为相同元素不存。如果为false,那么视为不同元素,就进行存储。

 

记住:如果元素要存储到HashSet集合中,必须覆盖hashCode方法和equals方法。

一般情况下,如果定义的类会产生很多对象,比如人,学生,书,通常都需要覆盖equals,hashCode方法。建立对象判断是否相同的依据。


自定义对象(保证对象的唯一):

public class Person{
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 int getAge() {
return age;
}
@Override
public int hashCode() {
return name.hashCode()+age*31;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
Person p = (Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
}
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
/**
 * @param args
 */
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add(new Person("lisi",38));
hs.add(new Person("lisi",38));
hs.add(new Person("zhangsan",17));
hs.add(new Person("zhaoliu",20));
Iterator it = hs.iterator();
while(it.hasNext()){
Person p = (Person)(it.next());
System.out.println(p.getName()+":"+p.getAge());
}
}
}


2.TreeSet:可以对Set集合中的元素进行排序。是不同步的。 


判断元素唯一性的方式:就是根据比较方法的返回结果是否是0,是0,就是相同元素,不存。 

TreeSet对元素进行排序的方式一:

让元素自身具备比较功能,就需要实现Comparable接口。覆盖compareTo方法。

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办?

 

覆盖compareTo方法

@Override
public int compareTo(Object obj) {
Person p = (Person)obj;
int temp = this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
}

可以使用TreeSet集合第二种排序方式二:

让集合自身具备比较功能,定义一个类实现Comparator接口,覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。因为有可能对象不具备比较器或者比较的功能不是我们所需要的。

import java.util.Comparator;
public class ComparetorByName implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Person p1 = (Person)o1;
Person p2 = (Person)o2;
int temp = p1.getName().compareTo(p2.getName()) ;
return temp==0?p1.getAge()-p2.getAge():temp;
}
}

自定义了比较器,就可以:

TreeSet ts = new TreeSet(new ComparetorByName());集合TreeSet自身就比较功能了。

 

五、map集合

 

形式:Map<K,V>

 

特点:

一次添加一对元素。而collection:一次添加一个元素

Map也称为双集合。Collection集合是单列集合

其实Map集合中存储的就是键值对

Map集合必须保证键的唯一性

 

常用的方法:

 

1.添加

 

value<key,value>,返回前一个和key关联的值value,没有返回null,存相同的键,值会覆盖

 

2.删除

Void clear():清空map集合

Value remove():根据指定的key翻出这个键值对

 

3.判断

boolean containsKey(key)

boolean containsValue(value)

boolean isEmpty()

 

4.获取

vlue get(key) : 通过键获取值,如果没有该键返回null

当然可以通过返null,来判断是否包含指定的键

 

int size():获取键值对的个数


方法的演示:

import java.util.HashMap;
import java.util.Map;
public class MapDemo {
/**
 * @param args
 */
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
method(map);
}
//学号和姓名
public static void method(Map<Integer, String> map){
//添加元素
System.out.println(map.put(8, "小王"));//null
System.out.println(map.put(8, "小陈"));//小陈,存相同的键,值会覆盖
System.out.println(map.put(2, "小李"));
System.out.println(map);
//删除
System.out.println(map.remove(8));
//判断
System.out.println(map.containsKey(8));
System.out.println(map.containsValue("小陈"));
//获取
System.out.println(map.get(2));
}
}

元素的取出:


方法一、

原理:通过keySet方法获取map中的所有键所在的set集合,再通过set的迭代器获取每一个,再对每一个键获取其对应的值即可。

 private static void method_2(Map<Integer, String> map) {
map.put(2, "lisi");
map.put(8, "wangcai");
map.put(5, "xiaowang");
map.put(7, "xiaowu");
Set<Integer> keySet = map.keySet();
Iterator<Integer > it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
}

方法2、

通过Map转换Set就可以迭代,找到另一个方法,entrySet,该方法将键和值映射关系作为对象存储到了Set集合中,而这个映射关系的类型就是Map.Entry类型(类似于结婚证书)

private static void method_3(Map<Integer, String> map) {
map.put(2, "lisi");
map.put(8, "wangcai");
map.put(5, "xiaowang");
map.put(7, "xiaowu");
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
}
 

values

private static void method_4(Map<Integer, String> map) {
map.put(2, "lisi");
map.put(8, "wangcai");
map.put(5, "xiaowang");
map.put(7, "xiaowu");
Collection<String> values = map.values();
Iterator<String> it = values.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}


 

Map常用的子类:

|--Hashtable :内部结构是哈希表,是同步的。不允许null作为键,null作为值。

|--Properties:用来存储键值对型的配置文件的信息,可以和IO技术相结

|--HashMap : 内部结构是哈希表,不是同步的。允许null作为键,null作为值。

|--TreeMap : 内部结构是二叉树,不是同步的。可以对Map集合中的键进行排序。

 

HashMap

存储自定义对象。

需求:将学生对象和学生归属地通过键与值存储到map集合中。

HashMap<Student , String> hm = new HashMap<Student, String>();
hm.put(new Student("lisi",27),"北京");
hm.put(new Student("wangwu",17),"上海");
hm.put(new Student("chenghong",77),"深圳");
hm.put(new Student("guicheng",57),"吉林");
hm.put(new Student("wangwu",17),"重庆");
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName()+":"+key.getAge()+":"+value);
}

TreeMap

存储自定义对象

需求:将学生按照姓名排序

TreeMap<Student , String> tm = new TreeMap<Student, String>(new CompartorByName());
tm.put(new Student("lisi",27),"北京");
tm.put(new Student("wangwu",17),"上海");
tm.put(new Student("chenghong",77),"深圳");
tm.put(new Student("guicheng",57),"吉林");
tm.put(new Student("wangwu",17),"重庆");
Set<Student> keySet = tm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext()){
Student key = it.next();
String value = tm.get(key);
System.out.println(key.getName()+":"+key.getAge()+":"+value);
}

比较器前面有详细的介绍。参照TreeSet


例子:

需求:"fdgavcbsacdfs" 获取该字符串中,每一个字母出现的次数。 要求打印结果是:a(2)b(1)...;

思路:

对于结果的分析发现,字母和次数之间存在着映射的关系。而且这种关系很多。

很多就需要存储,能存储映射关系的容器有数组和Map集合。

关系一方式有序编号吗?没有!

那就是使用Map集合。 又发现可以保证唯一性的一方具备着顺序如 a b c ...

所以可以使用TreeMap集合。

这个集合最终应该存储的是字母和次数的对应关系。 

1,因为操作的是字符串中的字母,所以先将字符串变成字符数组。

2,遍历字符数组,用每一个字母作为键去查Map集合这个表。 如果该字母键不存在,就将该字母作为键 1作为值存储到map集合中。如果该字母键存在,就将该字母键对应值取出并+1,在将该字母和+1后的值存储到map集合中,键相同值会覆盖。这样就记录住了该字母的次数.

3,遍历结束,map集合就记录所有字母的出现的次数。

 
public class MapTest {
/**
 * @param args
 */
public static void main(String[] args) {
String str = "nba+avAdc  cd5875dfhj-dvf";
String s = getCharCount(str);
System.out.println(s);
}
public static String getCharCount(String str) {
//将字符串变成字符数组 
char[] chs = str.toCharArray();
//定义map集合表。
Map<Character,Integer> map = new TreeMap<Character,Integer>();
for (int i = 0; i < chs.length; i++) {
if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
continue;
//将数组中的字母作为键去查map表。
Integer value = map.get(chs[i]);
int count = 1;
//判断值是否为null.
if(value!=null){
count = value+1;
}
map.put(chs[i], count);
}
return mapToString(map);
}
private static String mapToString(Map<Character, Integer> map) {
StringBuilder sb = new StringBuilder();
Iterator<Character> it = map.keySet().iterator();
while(it.hasNext()){
Character key = it.next();
Integer value = map.get(key);
sb.append(key+"("+value+")");
}
return sb.toString();
}
}
 

例子2、查表法

import java.util.HashMap;
import java.util.Map;
public class MapTest2 {
/**
 * @param args
 */
public static void main(String[] args) {
String week = getWeek(1);
System.out.println(week);
System.out.println(getWeekByMap(week));
}
public static String getWeekByMap(String week){
Map<String,String> map = new HashMap<String,String>();
map.put("星期一","Mond");
map.put("星期二","Tus");
map.put("星期三","Wes");
map.put("星期日","Sun");
map.put("星期天","Sun");
return map.get(week);
}
public static String getWeek(int week){
if(week<1 || week>7)
throw new RuntimeException("没有对应的星期,请您重新输入");
String[] weeks = {"","星期一","星期二"};
return weeks[week];
}
 
}
 

六、集合框架工具类

 

collections 

 

里面的方法是静态的

 

Sort方法

List<String> ls = new ArrayList<String>();
ls.add("cb");
ls.add("bvab");
ls.add("nbg");
ls.add("abc");
System.out.println(ls);
//对list结合进行指定排序
Collections.sort(ls);
System.out.println(ls);	//[abc, bvab, cb, nbg, yyy]<span style="font-size:14px; font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

折半查找和求最值

List<String> ls = new ArrayList<String>();
ls.add("cb");
ls.add("bvab");
ls.add("nbg");
ls.add("abc");
ls.add("yyy");
//对list结合进行指定排序
Collections.sort(ls);
//折半查找
int index = Collections.binarySearch(ls, "nbg");
//最值
String max = Collections.max(ls);
System.out.println(ls);	//[abc, bvab, cb, nbg, yyy]
System.out.println(max);	//yyy
System.out.println(index);	//3

逆序和替换

逆序

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
ts.add("abc");
ts.add("nba");
ts.add("yyy");
ts.add("uuu");
System.out.println(ts);

原理:用到之前说的比较器

替换

List<String> ls = new ArrayList<String>();
ls.add("cb");
ls.add("bvab");
ls.add("nbg");
System.out.println(ls);
Collections.replaceAll(ls, "bvab", "nba");//将bvab替换成nba
System.out.println(ls);

原理:用到set(indexOf("bvab"),"nba");

 

fill方法


Collections.fill(ls, "bb");

 

将集合中的所有元素替换成bb,相当于初始化


Shuffle方法

 

Collections.shuffle(ls);

 

将集合中的元素随机位置排序


将非同步集合转换成同步集合(重要)

 

Collections中的的方法

 

Collections.synchronizedXXX,其中XXX是集合,例如Map,Set,Collection

 

方法的解释:

 

方法用到加锁的方法

 
List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
给非同步的集合加锁。
class MyCollections{
public static  List synList(List list){
return new MyList(list);
}
//内部类
private class MyList implements List{
private List list;
private static final Object lock = new Object();
MyList(List list){
this.list = list;
}
public boolean add(Object obj){
synchronized(lock){
return list.add(obj);
}
}
public boolean remove(Object obj){
synchronized(lock){
return list.remove(obj);
}
}
}
}
 

Arrays

 

集合框架的工具类

里面的方法都是静态的

 

toString方法

 

int[] arr = {1,5,8,4,3,9};
System.out.println(Arrays.toString(arr));
 
//toString的经典实现
public static String toString(int[] a) {
   if (a == null)
     return "null";
int iMax = a.length - 1;
if (iMax == -1)
     return "[]";
StringBuilder b = new StringBuilder();
 b.append('[');
 for (int i = 0; ; i++) {//中间省略了条件的判断,提高了效率
     b.append(a[i]);
 if (i == iMax)
return b.append(']').toString();
 b.append(", ");
   }
}


将数组转换成List集合。

 

asList方法(重点)

 

原因:数组中的方法过于简单,比如想知道数组中有没这个元素,数组就实现不了,所以需要转成集合。

 

例子:

String[] arr = {"haha","huhu","yiyi"};
List<String> list = Arrays.asList(arr);
boolean b  = list.contains("xixi");
System.out.println(b);

转正集合的好处:

可以使用集合中的方法操作数组

 

注意1:数组的长度是固定的,所以对于集合的增删方法是不可以使用的,否则会发生java.lang.UnsupportedOperationException异常

 

注意2:如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储;如果数组中的元素是基本数据类型数值,那么会将数组作为集合中的元素进行存储。


例子:

int[] arr = {1,8,2,6};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);	//	[[I@544a5ab2]


集合转数组

 

使用的是Collection接口中的toArray方法

可以对集合中的操作的方法进行限定,不允许进行增删

List<String> list = new ArrayList<String>();
list.add("abc");
list.add("nba");
String[] arr = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));

toArray方法中需要指定类型的数组

 

长度如果定义呢?

 

如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size数组

如果长度大于集合的size,那么该方法就会使用指定的数组,存储集合中的元素,其他位置默认为NULL,所以建议,最后长度就指定位集合的size

 

 

七、foreach语句

 

格式:

for(类型 变量 : Collec 集合 或者 数组) 

 

例子:

List<String> list = new ArrayList<String>();
list.add("abc");
list.add("nba");
list.add("cba");
for(String s : list){
System.out.println(s);
}

传统的for和高级的for的区别

 

传统for可以完成对语句执行痕对此,因为可以定义控制循环的增量的条件

 

高级for是一种简化形式

它必须有被遍历的目标,该目标要么是数组,要么是Collection单列集合

 

对数组的遍历如果仅仅是获取数组中的元素,可以使用高级for,

如果要对数组的角标进行操作,建议使用传统for

 

遍历map集合

Map<Integer, String> map = new HashMap<Integer, String>();
map.put(3, "zhangsan");
map.put(14, "xiaowang");
map.put(24, "lisi");
for(Integer key :map.keySet()){
String value = map.get(key);
System.out.println(key+":"+value);
}
for(Map.Entry<Integer,String> me:map.entrySet()){
Integer key  =me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}

八、函数的可变参数

 

private static void teat3() {
int sum = newAdd(1,5,7,9);
System.out.println("sum="+sum);
}
private static int newAdd(int a,int... arr) {
int sum = 0;
for(int i = 0;i<arr.length; i++){
sum+=arr[i];
}
return sum;
}

其实就是一个数组,但是接收的是数组的元素,自动将这些元素封装成数组,简化了调用者的书写

注意:可变参数类型,必须定义在参数列表的结尾。

 

用处:在asList中可用

 

 

九、静态的导入

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入,其实导入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入,其实导入的是类中的静态成员。
 
import static java.lang.System.*;
public class StaticImportDemo {
/**
 * @param args
 */
public static void main(String[] args) {
 
List<String> list = new ArrayList<String>();
list.add("abc3");
list.add("abc7");
list.add("abc1");
out.println(list);
sort(list);
System.out.println(list);
String max = max(list);
System.out.println("max="+max);
}
}


 

------Java培训Android培训iOS培训.Net培训、期待与您交流!-------



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值