黑马程序员————集合类
来源:互联网 发布:rekordbox软件的作用 编辑:程序博客网 时间:2024/06/13 23:33
------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();//清空集合col1System.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");elseSystem.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;}@Overridepublic int hashCode() {return name.hashCode()+age*31;}@Overridepublic 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方法
@Overridepublic 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 {@Overridepublic 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, "小王"));//nullSystem.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);//yyySystem.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替换成nbaSystem.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培训、期待与您交流!-------
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员—集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 黑马程序员——集合
- 24-IO流-55-IO流(ObjectOutputStream-对象的序列化)
- Push和Modal的区别
- NVMe的目标:释放闪存潜能
- pageX,clientX,screenX,offsetX区别
- 白话设计模式之--策略模式
- 黑马程序员————集合类
- 定时器的使用
- java统计字符串中各个字符的出现次数
- hdoj-1242-Rescue【广搜+优先队列】
- 24-IO流-56-IO流(ObjectInputStream-对象的反序列化)
- transform
- 一个简单的串行协议的封装
- 类别和类扩展的区别
- 单例