黑马程序员技术交流社区

标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day16（集合）！ [打印本页]

作者: 阳哥忠粉 时间: 2015-6-6 22:52
标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day16（集合）！

笔记总链接：http://bbs.itheima.com/thread-200600-1-1.html

6、集合

6.1 常用对象

6.1.2 基本数据类型对象包装类

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

用于描述该对象的类就称为基本数据类型对象包装类。
byte    Byte
short    Short
int       Integer
long    Long
float    Float
double Double
char    Character
boolean Boolean

该包装对象主要用于基本类型和字符串之间的转换
基本类型-->字符串
1. 基本类型数值+""
2. 用String类中的静态方法valueOf(基本类型数值);

字符串-->基本类型
1. 使用包装类中的静态方法xxx parseXxx("xxx");
      int parseInt(String str);
      long parseLong(String str);
      boolean parseBoolean(String str);
      只有Character没有parse方法。
2. 如果字符串被Integer进行对象的封装，可使用另一个非静态的方法，intValue。
      将一个Integer对象转成基本数据类型值。
3. 用Integer的静态方法valueOf(String s);

示例1：

public class WrapperDemo{
public static void main(String[] args){
//整型最大值
System.out.println(Integer.MAX_VALUE);
//十进制转换成二进制
System.out.println(Integer.toBinaryString(6));
}
}

复制代码

运行结果：

示例2：

public class WrapperDemo{
public static void main(String[] args){
Integer i = new Integer(5);
System. out.println(Integer.parseInt( "123") + 1);
}
}

复制代码

运行结果：

示例3：

public class WrapperDemo{
public static void main(String[] args){
if(Boolean.parseBoolean("true" ))
System.out.println( "true");
Integer i = new Integer("123" );
System.out.println(i.intValue());
}
}

复制代码

运行结果：

整数具备不同的进制体现。
十进制-->其他进制方法：
String toBinaryString(int i);
String toOctalString(int i);
String toHexString(int i);
String toString(int i,int radix);

示例4：

public class WrapperDemo{
public static void main(String[] args){
System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.toOctalString(60));
System.out.println(Integer.toHexString(60));
System.out.println(Integer.toString(60,4));
}
}

复制代码

运行结果：

其他进制-->十进制方法：
int parseInt(String s,int radix);

示例5：

public class WrapperDemo{
public static void main(String[] args){
System.out.println(Integer.parseInt("110",10));
System.out.println(Integer.parseInt( "3C",16));
}
}

复制代码

运行结果：

需求：
对一个字符串中的数值进行从小到大的排序。
"20 78 9 -7 88 36 29"
代码：

import java.util.Arrays;
public class WrapperTest{
private static final String SPACE_SEPARATOR = " ";
public static void main(String[] args){
String numStr = "20 79 9 -7 88 36 29";
System.out.println(numStr);
numStr = sortStringNumber(numStr);
System.out.println(numStr);
}
public static String sortStringNumber(String numStr){
//1、将字符串变成字符串数组
String[] str_arr = stringToArray(numStr);
//2、将字符串数组变成int数组
int[] num_arr = toIntArray(str_arr);
//3、对int数组排序
mySortArray(num_arr);
//4、将排序后的int数组变成字符串
String temp = arrayToString(num_arr);
return temp;
}
public static String arrayToString(int[] num_arr){
StringBuilder sb = new StringBuilder();
for(int x = 0; x < num_arr.length; x++){
if(x!=num_arr.length - 1)
sb.append(num_arr[x] + SPACE_SEPARATOR);
else
sb.append(num_arr[x]);
}
return sb.toString();
}
public static void mySortArray(int[] num_arr){
Arrays.sort(num_arr);
}
public static int[] toIntArray(String[] str_arr){
int[] arr = new int[str_arr.length];
for(int i = 0; i < arr.length; i++){
arr[i] = Integer.parseInt(str_arr[i]);
}
return arr;
}
public static String[] stringToArray(String numStr){
String[] str_arr = numStr.split(SPACE_SEPARATOR);
return str_arr;
}
}

复制代码

运行结果：

6.2 集合类

集合类的由来：
对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

集合特点：
1. 用于存储对象的容器。
2. 集合的长度是可变的。
3. 集合中不可以存储基本数据类型值。

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

P.S.
数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
数组中可以存储基本数据类型，集合只能存储对象。

集合框架的构成及分类：

6.2.1 Collection接口

框架的顶层Collection接口：

Collection的常见方法：
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(Collection coll);
boolean isEmpty();判断集合中是否有元素。

4、获取：
int size();
Iterator iterator();
取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在容器中进行内部实现的，也就是iterator方法在每个容器中的实现方式是不同的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5、其他：
boolean retainAll(Collection coll);取交集
Object toArray();将集合转成数组

示例1：

import java.util.*;
public class CollectionDemo{
public static void main(String[] args){
Collection coll = new ArrayList();
show(coll);
System.out.println( "---------------------------------" );
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2);
}
public static void show(Collection coll){
//1、添加元素，add
coll.add( "abc1");
coll.add( "abc2");
coll.add( "abc3");
System.out.println( "coll:" + coll);
//2、删除元素，remove
coll.remove( "abc2");//会改变集合的长度
System.out.println( "coll:" + coll);
//清空集合
//coll.clear();
System.out.println(coll.contains( "abc1"));
}
public static void show(Collection c1,Collection c2){
//给c1添加元素
c1.add( "abc1");
c1.add( "abc2");
c1.add( "abc3");
c1.add( "abc4");
//给c2添加元素
c2.add( "abc2");
c2.add( "abc6");
c2.add( "abc7");
System.out.println( "c1:" + c1);
System.out.println( "c2:" + c2);
//演示addAll
//将c2中的元素添加到c1中
c1.addAll(c2);
//演示removeAll
//从c1集合中删除与c2集合相同的元素
boolean b = c1.removeAll(c2);
System.out.println( "removeAll:" + b);
//演示containsAll
boolean b1 = c1.containsAll(c2);
System.out.println( "containsAll:" + b1);
//演示retainAll
//取交集，保留和指定的集合相同的元素
boolean b2 = c1.retainAll(c2);
System.out.println( "c1、c2交集:" + c1);
}
}

复制代码

运行结果：

示例2：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo{
public static void main(String[] args){
Collection coll = new ArrayList();
coll.add( "abc1");
coll.add( "abc2");
coll.add( "abc3");
coll.add( "abc4");
System.out.println(coll);
//使用了Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
Iterator it1 = coll.iterator();
while(it1.hasNext()){
System.out.println(it1.next());
}
//for循环结束，Iterator变量内存释放，更高效
for(Iterator it2 = coll.iterator();it2.hasNext();){
System.out.println(it2.next());
}
}
}

复制代码

运行结果：

6.2.2 List、Set

Collection
          |--List：有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素。
          |--Set：元素不能重复，无序。

List：特有的常见方法。
有一个共性特点就是都可以操作角标。
1、添加
          void add(index,element);
      void addAll(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);

List集合可以完成对元素的增删改查。

示例1：

import java.util.ArrayList;
import java.util.List;
public class ListDemo{
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);
//插入元素
list.add(1, "abc2" );
//删除元素
System.out.println( "remove:" + list.remove(2));
//修改元素
System.out.println( "set:" + list.set(1,"abc8" ));
//获取元素：
System.out.println( "get:" + list.get(0));
//获取子列表
System.out.println( "sublist:" + list.subList(1,2));
System.out.println(list);
}
}

复制代码

运行结果：

示例2：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo{
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");
list.add( "abc4");
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
//list特有的取出元素的方式之一
for(int x = 0; x < list.size(); x++){
System.out.println( "get:" + list.get(x));
}
}
}

复制代码

运行结果：

示例3：

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

复制代码

运行结果：

在迭代器过程中，不要使用集合操作元素，容易出现异常：java.util.ConcurrentModificationException。
可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。

示例4：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo{
public static void main(String[] args){
List list = new ArrayList();
list.add( "abc1");
list.add( "abc2");
list.add( "abc3");
System.out.println( "list:" + list);
ListIterator it = list.listIterator(); //获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查。
//注意：只有list集合具备该迭代功能。
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc3" )){
it.add( "abc9");
}
}
System.out.println( "hasNext:" + it.hasNext());
System.out.println( "hasPrevious:" + it.hasPrevious());
while(it.hasPrevious()){
System.out.println( "previous:" + it.previous());
}
System.out.println( "list:" + list);
}
}

复制代码

运行结果：

~END~

~爱上海，爱黑马~

作者: yijian2033 时间: 2015-6-6 23:04
谢谢阳哥，刚好可以用上

作者: SouthKai 时间: 2015-6-6 23:35
真是比看书还方便

作者: 集体烧书 时间: 2015-6-7 18:25
刚刚看到这里，表示很有帮助，非常感谢

作者: 铃铃铃铃铃锋 时间: 2015-6-10 11:45
谢谢分享~

作者: 少年闰土 时间: 2015-6-10 18:38
6.2.2中list特有的方法中有个小问题
是addAll(index, Collection);
你写成了add(index, Collection);
不知道我的判断正确吗？

作者: wx_iAuO26mH 时间: 2015-6-15 23:05
看完今天的视频，预习明天的课程

作者: 草原上的小黑马 时间: 2015-6-16 23:31
不错值得收藏

作者: 魏海洲 时间: 2015-6-19 19:19

谢谢阳哥，刚好可以用上

作者: 魏海洲 时间: 2015-6-22 21:27
真是比看书还方便

作者: 魏海洲 时间: 2015-6-23 21:24

刚刚看到这里，表示很有帮助，非常感谢

作者: 魏海洲 时间: 2015-6-23 21:33

不错值得收藏

作者: Ann闇 时间: 2015-6-23 21:36
虽说好多都还没学到，不过以后还是有好大帮助的，非常感谢

作者: Z、c 时间: 2015-7-4 09:09
每日学习签到！！！

作者: twa42 时间: 2015-7-9 15:45
学习了，谢谢老师

作者: pi408637535 时间: 2015-7-16 16:08
不错值得收藏

作者: 星痕-凌 时间: 2015-7-17 21:24
不错、顶！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

作者: 小哥黑马 时间: 2015-7-18 00:08
阳哥发的都是精华

作者: kime 时间: 2015-8-24 09:29
学习了，very good

作者: 放心飞 时间: 2015-8-29 12:10
又看完一节了，加油继续努力！

作者: yangshibai 时间: 2015-9-21 23:28
不错，学习了。

作者: xuxu5112 时间: 2015-9-21 23:45
复习下集合

作者: 放心飞 时间: 2015-9-27 23:55
每天的学习生活都让我觉得生活很充实，晚安。明天继续？。。

作者: 放心飞 时间: 2015-9-28 23:27
看完这一节，继续前行，加油。

作者: 乱世心 时间: 2015-9-29 21:18
努力第三天了

作者: 13120298870 时间: 2016-5-3 00:45
做测试的时候正好瞄了两道题，嘿嘿

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2