黑马程序员_类库与集合总结

------- android培训、java培训、期待与您交流！ ----------



Object类： 它是所有类的超类
需要掌握的方法：
toString():返回该对象的字符串表示
equals(Object obj): 指示其他某个对象是否与此对象“相等
finalize()： 用来释放 对象垃圾
getClass():返回此 Object 的运行时类。
hashCode():返回该对象的哈希码值 ，它是一个逻辑值。 它不是真正的内存地址



Scanner类它是一个获取键盘输入的数据的封装类
nextInt() 获取int数据类型的数据
nextLine() 获取字符串数据


 
  使用Scanner中的方法的注意事项
 
  String -- String 可以使用
  String -- int 可以使用
   int -- int 可以使用
   int -- String 不可以
   后面的String ： \r\n
   转义字符：
   \r: 换行符
   \n: 回车符
  
   就要先int， 后String 怎么办？
   A: 再新创建一个Scanner 对象
   B: 把int数据 看做 String来处理, 处理后，将String 数据转换成 int


String类  String 类代表字符串
构造函数：
public String()： 空参数构造函数
  public String(byte[] bytes): 把给定的字节数组 转换成字符串
  public String(byte[] bytes,int startIndex,int length): 把给定的字节数组的一部分 转换成字符串 (包含startIndex位置的元素)
  public String(char[] value): 把 给定的字符数组 转换成字符串
  public String(char[] value,int startIndex,int length): 把给定的字符数组的一部分 转换成字符串(包含startIndex位置的元素)
  public String(String original)：把字符串 转换成 字符串
字符串一旦创建就不会被改变  变量在常量池中不管有没有都创建新的

判断功能:
boolean equals(Object obj):  比较两个字符串内容是否相同
boolean equalsIgnoreCase(String str): 比较两个字符串内容是否相同(忽略大小写)
boolean contains(String str): 判断该字符串是否包含给定的字符串
boolean startsWith(String str)： 判断该字符串是否以 给定的字符串开头
boolean endsWith(String str): 判断该字符串是否以给定的字符串结尾
boolean isEmpty(): 判断该字符串是否为空  ""


获取功能:
int length(): 获取字符串的长度
char charAt(int index): //把该字符串中给定位置的字符返回
int indexOf(int ch): //byte short char int 返回给定字符在字符串中第一次出现的位置
int indexOf(String str);//返回给定的字符串在该字符串中第一次出现的位置
int indexOf(int ch,int fromIndex): 在指定位置开始，返回给定字符在字符串中第一次出现的位置
int indexOf(String str,int fromIndex)在指定位置开始，返回给定的字符串在该字符串中第一次出现的位置
String substring(int start): 在指定位置开始，截取该字符串，返回一个新字符串
String substring(int start,int end)在指定位置开始，到指定位置结束，截取该字符串，范返回一个新字符串(包左不包右)

转换功能:
byte[] getBytes(): 把该字符串 转换成 字节数组
char[] toCharArray(): 把该字符串 转换成字符数组
static String copyValueOf(char[] chs): 把给定的字符数组 转换为 字符串
static String valueOf(char[] chs): 把给定的字符数组 转换为 字符串
static String valueOf(int i)基本类型: 把给定的int数据 转换成字符串
String toLowerCase(): 把该字符串转换成小写字母
String toUpperCase(): 把该字符串转换成大写字母
String concat(String str): 字符串连接

练习:
== 与 equals的区别?
==：
如果比较的基本数据类型的数据，比较的是数据的值
如果比较的引用数据类型的数据，比较的地址值
  
   equals:
比较的引用数据类型的数据， 默认比较的是地址值
推荐 重写 此方法

String对象面试题
A:字符串一旦初始化就不可以被改变
但是字符串中存放的地址是可以改变的

B: String s1 = new String(“abc”);
String s2 = “abc”;
有区别吗？

C:写出程序的运行结果
如果操作的是常量， 先看常量池中有没有，有，直接使用，否则，构建出来
如果操作的是变量， 直接构建



String:
替换功能
String replace(char old,char new)： 在该字符串中，用指定的新字符 替换  指定老字符
String replace(String old,String new)： 在该字符串中， 用指定的新字符串 替换 指定的老字符串 
切割
String[] split(String regex): 使用给定的分隔符，将该字符串分解成多个字符串
去除字符串两空格
String trim()
按字典顺序比较两个字符串 
int compareTo(String str)
int compareToIgnoreCase(String str)
Arrays:
public static String toString(int[] a): 把数组转换成字符串
public static void sort(int[] a): 把数组排序
public static int binarySearch(int[] a,int key): 二分查找法

StringBuffer:
   构造函数：
   public StringBuffer()： 容量为 16 个字符
   public StringBuffer(int capacity): 容量为指定的大小
   public StringBuffer(String str): 容量为16字符 + 字符串的长度
   需要掌握的方法:
   public int capacity() 理想使用情况
   public int length() 实际使用情况
   添加元素相关的方法：
public StringBuffer append(String str)： 在该字符串后面 追加给定的字符串   ，返回此对象的一个引用。
  其实返回的对象引用就是该对象本身
public StringBuffer insert(int offset,String str): 在给定位置，插入给定的字符串到原字符串中

   删除元素的方法：
public StringBuffer delete(int start,int end): 从指定位置开始到指定位置结束的数据在该字符串中删除 ，
       返回此对象
public StringBuffer deleteCharAt(int index)： ：把指定位置的字符在字符串中删除, 返回此对象

   替换元素
public StringBuffer replace(int start,int end, String str)
从指定的开始位置，到指定的结束位置，把原来的数据 替换为 新的字符串数组
   截取子串
public String substring(int start)
从给定位置开始，截取该字符串,返回截取后一个新字符串

public String substring(int start,int end)
从给定位置开始，到给定的位置结束，截取该字符串，返回截取后的一个新字符串
   反转
public StringBuffer reverse()
abc --> cba

Integer:
字段： 成员变量
最大值 2^31 -1
最小值 -(2^31)

Integer类的构造函数
  public Integer(int value): 把指定的int数据 转换成 Integer对象
 
  public Integer(String s)：把指定的字符串 转换成 Integer对象
    使用要求： 字符串只能有 数字字符 所组成 "12345"

方法：
进制转换
public static String toBinaryString(int i): 将给定的10进制数 转换为 2进制，以字符串的形式显示
   public static String toHexString(int i): 将给定的10进制数 转换为16进制，以字符串的形式显示
   public static String toOctalString(int i): 将给定的10进制数 转换为8进制，以字符串的形式显示
   public static String inVolue
   public static int parseInt(String s): 将字符串 转换为 int数据
   public static int parseInt(String s,int radix):把给定进制的字符串 转换为 10进制


Integer:
自动装箱: int数据 --> 对象
自动拆箱: 对象 --> int数据

Random:
构造函数：
public Random() : 使用默认种子来生成随机数对象.  默认种子指的是当前时间的毫秒值
public Random(long l): 使用给定的种子来生成 随机数对象， 注意：当种子相同时，随机数也是一样的
方法：
nextInt(); 获取int数据范围内的随机数
nextInt(int n); 获取[0,n)这个范围内的随机数

Date:
构造函数：
public Date(): 当前日期对象
public Date(long l): 给定毫秒数 对应的日期对象  （日期是从1970年1月1月 00:00:00开始计算的）

方法：
日期与毫秒数转换
public long getTime()  用来得到当前时间对象 对应的毫秒数

DateFormat
构造函数
public SimpleDateFormat()：采用默认模式与默认语言区域生成日期格式化对象
public SimpleDateFormat(Stirng format): 采用给定的模式与默认语言区域生成日期格式化对象
方法：
把日期 格式化成 字符串
public final String format(Date date)

按照指定的格式，将字符串解析成日期对象
public Date parse(String source)

Calendar:
方法：
public static Calendar getInstance()： 获取一个Calendar类对象
public abstract void add(int field, int amount): 将当期日期对象中的给定字段进行修改 amount
public int get(int field)： 获取当前日期对象中 给定的字段值
public final void set(int year,int month, int date): 设置当期日期对象中 年月日等


System：
方法：
public static void gc()： 运行垃圾回收器
public static void exit(int status) 终止当前正在运行的 Java 虚拟机。
    参数用作状态码；根据惯例，非 0 的状态码表示异常终止
public static long currentTimeMillis()： 返回以毫秒为单位的当前时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。



StringBuilder和StringBuffer
1.StringBuilder和StringBuffer与String的区别
StringBuilder和StringBuffeer是可变字符序列
String是不变得,一但被初始化,就不能改变

2.StringBuilder和StringBuffer的区别
StringBuilder是线程不安全的,所以效率比较高,1.5版本出现
StringBuffer是线程安全的,效率相对较低,1.0版本出现的


BigInteger
1.创建对象
可以使用BigInteger(String)来创建一个很大的整数, 精度可以无限大, 值创建之后不会被改变(类似String)
2.常用方法
BigInteger add(BigInteger val) //加
BigInteger subtract(BigInteger val) //减
BigInteger multiply(BigInteger val) //乘
BigInteger divide(BigInteger val) //除
BigInteger mod(BigInteger m ) //模
BigInteger max(BigInteger val) //两个数的最大值
BigInteger min(BigInteger val) //两个数的最小值

BigDecimal
1.创建对象
BigDecimal(double); //不建议用,运算结果不精确
BigDecimal(String); //可以,但是每次都要传字符串给构造函数
static BigDecimal valueOf(double) //可以,而且可以直接传double数
因为double数是不精确,是无限接近那个数,用BigDemal这个类可以让其精确
2.常用方法
BigDecimal add(BigDecimal augend)
BigDecimal subtract(BigDecimal subtrahend)
BigDecimal multiply(BigDecimal multiplicand)
BigDecimal divide(BigDecimal divisor)




包装类
1.什么是包装类
8种基本数据类型都会对应一个包装类
int是Integer, char是Character, 其他都是首字母大写double Double short Short boolean Boolean
2.什么时候使用
集合的泛型中只能写包装类型
后面的课程中会学到集合, 集合是只能装对象的, 而基本数据类型不是对象不能直接装入
在JDK5之前, 如果想把基本数据类型装入集合, 必须人工的进行包装(转为包装类对象)
JDK5之后, 基本数据类型和包装类之间可以自动的互相转换了
Integer i = 10;
int x = i + 20;
Integer i1 = 98;
Integer i2 = 98;
i1 == i2?
Integer i3 = 198
Integer i4 = 198
i3== i4
3.包装类常用的方法
static int parseInt(String s) 将数字字符串转换成数字,如果是非数字字符串会转换失败,抛异常
Integer.toBinaryString() 将一个十进制数字,转换成二进制的字符串
Integer.toOctalString() 将一个十进制数字,转换成八进制的字符串
Integer.toHexString() 将一个十进制数字,转换成十六进制的字符串
static long parseLong(String s)
static double parseDouble(String s)
static char forDigit(int digit, int radix)// radix代表的是进制例如二进制就传2,八进制就传8,digit代表后面进制里面的元素,而且不能超出后面进制的范围



集合的概念
1.什么是集合
集合是一种容器, 长度可变, 可以存储任意类型的对象.
基本数据类型也可以装入集合, 但其实内部是先自动装箱成包装类对象, 然后再存入集合的


  @param args
  数组和集合的区别
  1,数组可以存储基本数据类型变量,也可以存储引用数据类型变量(对象)
    集合只能存储对象
  2,数组长度是固定的,一旦被初始化就不能被改变
    集合的长度是可变的,随着向集合中添加的元素增多而增长
  3,具体用哪个?就看长度是否固定
    如果长度固定,建议用数组,效率高
   如果长度不固定,建议用集合,因为集合底层封装了自动增长的功能
   


接口没有继承Object,但是只要是定义成接口,jvm会将Object里面所有的方法定义在接口中,并且都是抽象的(支持这种)


集合的分类
1.Collection
  List: 可重复, 有存储顺序
ArrayList 数组实现, 增删慢, 查找快
LinkedList 链表实现, 增删快, 查找慢
Vector 数组实现, 原理和ArrayList相同, 但线程安全
Set
HashSet
TreeSet
LinkedHashSet
2.Map
HashMap
TreeMap
Hashtable
LinkedHashMap
Properties   性能
集合的常用方法
1.常用方法
add(Object obj) 向集合中添加一个元素, 添到最后的位置
get(int index)    获取集合中指定位置的元素
size()          获取集合的长度
add(int index, Object obj) 向集合中添加一个元素, 添到指定位置
set(int index, Object obj) 把集合中指定位置的元素替换
remove(int index) 删除集合中指定位置的元素
remove(Object obj) 删除集合中包含的obj对象(遍历集合中的元素如果传入的元素equals某个元素就调用remove方法,注意:角标要--)
2.迭代集合
a.for循环: 从0循环到集合的size()-1, 每次获取其中一个
b.迭代器:  调用iterator()方法获取迭代器, 使用hasNext()判断是否包含下一个元素, 使用next()获取下一个元素
c.增强for循环: for (类型 变量名 : 容器) { 循环体 } 容器中有多少个元素就执行多少次循环体, 每次循环变量指向容器中不同的元素
3.迭代时删除的问题
a.for循环: 删除时由于后面的元素会向前移动, 所以删除之后循环变量要--
b.迭代器:  要删除元素时必须使用Iterator中的remove()否则会抛出异常
c.增强for循环: 不能删除



集合的分类
Collection 一次存一个对象, 单列集合
List 可重复, 有索引
ArrayList 数组实现, 查找快
LinkedList 链表实现, 增删快
Vector 数组实现, 线程安全
Set  不可重复, 没索引
HashSet 使用哈希算法去重复, 效率高, 但元素无序
TreeSet TreeSet是用排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
LinkedHashSet HashSet的子类, 原理相同, 除了去重复之外还能保留存储顺序
HashSet
1.HashSet原理
我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低
哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
如果没有哈希值相同的对象就直接存入集合
如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较
比较结果为false就存入, true则不存
2.将自定义类的对象存入HashSet去重复
类中必须重写hashCode()和equals()方法
hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储
迭代(遍历)
1.List
a.普通for循环, 使用get()逐个获取
b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
c.增强for循环, 只要可以使用Iterator的类都可以用
d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法
2.Set
a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
b.增强for循环, 只要可以使用Iterator的类都可以用
TreeSet
1.特点
TreeSet是用排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
2.使用方式
a.自然顺序(Comparable)
TreeSet类的add()方法中会把存入的对象强转成Comparable类型
调用对象的compareTo()方法和集合中的对象比较
根据compareTo()方法返回的结果进行存储
b.比较器顺序(Comparator)
创建TreeSet的时候可以制定 一个Comparator
如果传入了Comparator, 那么TreeSet就不会按照自然顺序排序了
add()方法内部会自动调用Comparator接口中compare()方法排序
c.两种方式的区别
TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
TreeSet如果传入Comparator, 就优先按照Comparator



集合的分类
Collection 一次存一个对象, 单列集合
List 可重复, 有索引
ArrayList 数组实现, 查找快
LinkedList 链表实现, 增删快
Vector 数组实现, 线程安全
Set  不可重复, 没索引
HashSet 使用哈希算法去重复, 效率高, 但元素无序
TreeSet 使用二叉树算法排序, 可以指定元素的存储顺序
LinkedHashSet HashSet的子类, 原理相同, 除了去重复之外还能保留存储顺序
Map 一次存两个对象, 键值对
HashMap 使用哈希算法对键去重复, 效率高, 但无序
TreeMap 使用二叉树算法排序, 可以自定义顺序
LinkedHashMap 使用哈希算法去重复, 并且保留存储顺序
Hashtable 类似HashMap, 线程安全, 效率略低, 不允许null键和null值
Properties Hashtable的子类, 用来操作配置文件
Map集合
1.Map集合的特点
Map集合一次存储两个对象, 一个键对象, 一个值对象
键对象在集合中是唯一的, 可以通过键来查找值
2.Map常用方法
put() 存储一条记录, 一个键和一个值
get() 根据键对象获取值
containsKey() 判断是否包含指定的键
containsValue() 判断是否包含指定的值
remove() 根据键删除一条记录
size() Map集合中的记录数
values() 得到所有的值对象组成的一个Collection集合
3.迭代Map集合
a.keySet()
先调用keySet()方法从Map集合中获取所有Key组成的一个Set集合
迭代Set集合可以得到每一个Key
然后再调用get()方法通过Key获取每一个Value
b.entrySet()
先调用entrySet()方法从Map集合中获取所有Entry(键值对)组成的一个Set集合
迭代Set集合可以得到每一个Entry
然后再调用getKey()和getValue()方法得到每一个Key和每一个Value
4.HashMap
在使用HashMap存储键值对的时候, 先调用Key对象的hashCode()方法计算一个哈希值, 在Map中查找是否有相同哈希值的Key对象
如果没有哈希值相同的Key对象, 这个键值对直接存入
如果有哈希值相同的Key对象, 那么就进行equals比较
比较结果为false就存入, true则覆盖原Value
5.LinkedHashMap
HashMap的子类, 算法相同, 但保留了存储的顺序
6.TreeMap
在使用TreeMap存储键值对的时候, 会使用Key对象和集合中已存储的Key对象进行比较, 确定二叉树上的位置
比较的方式和TreeSet指定的方式相同, Comparable和Comparator
7.Hashtable
类似HashMap, 线程安全, 效率略低, 不允许null键和null值
8.Properties
Hashtable的子类, 用来操作配置文件

集合的迭代
1.Collection
Iteraotr:   通过iterator()方法得到迭代器, 调用hasNext()和next()方法进行迭代
ForEach:    for (类型  变量名 : 容器) { 循环体 }
2.Map
keySet():   得到所有的键组成的Set, 遍历Set得到每一个键, 然后再分别获取值
entrySet(): 得到所有的Entry组成的Set, 遍历Set得到每一个Entry, 再分别getKey()和getValue()
3.List
Iterator
ForEach
for: 根据索引定义for循环, 调用get()方法根据索引获取每一个元素
4.Vector
Iterator
ForEach
for
Enumeration: 类似Iterator, 通过elements()方法得到Enumeration, 调用hasMoreElements()和nextElement()方法进行迭代









  共同点:底层都是数组实现的
  区别:
  1,Vector中方法遍历麻烦,方法名太长
  2,ArrayList底层一旦添加元素超过了指定长度,50%倍增长
    Vector底层一旦添加元素超过了指定长度,100%增长
  3,ArrayList是线程不安全的,效率高
    Vector是线程安全的,效率低

ListIterator   有add方法  还有hasPrevious  倒序遍历  但要注意必须先要正者遍历


LinkedList里面的
poll    和remove一样删除       remove要是元素不存在就抛异常  poll不是返回null
peek  get和一样   获取


Collections.sort(list,Collections.reverseOrder()); 将原来的自然排序反转
Collections.sort(list, Collections.reverseOrder(new CompareByLen())); 将比较器反转
Collections.reverse(list); 将集合反转
Collections.swap(list, 2, 5); 换位
Collections.replaceAll(list, "a", "z"); 替换
Collections.shuffle(list); 随机置换

int index = Collections.binarySearch(list, "e"); 如果找不到-(插入点) - 1
;




sort()对指定列表按升序进行排序。
sort(List<T> list, Comparator<? super T> c)对指定的列表用我们指定的方式排序
reverseOrder()返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
reverseOrder(Comparator<T> cmp)返回一个比较器，它强行逆转指定比较器的顺序。也可用作参数的形式传给TreeSet
max和min//max(list)//max(list,比较器);
binarySearch()对有序的集合二分查找
fill(List<? super T> list, T obj)用obj将集合中的元素替代
reverse(List<?> list)集合反转
swap(List<?> list, int i, int j);指定位置的交换
replaceAll(List<T> list, T oldVal, T newVal)新元素替换老元素
synchronizedList(List<T> list)返回指定列表支持的同步（线程安全的）列表
shuffle(List<?> list);对集合中的元素随机置换




jdk1.5的新特性静态导入,开发根本不用
静态导入其实导入的是这个类中静态方

String[] arr = list.toArray(new String[list.size()]); 集合转数组
List<Integer> list = Arrays.asList(arr);如果想数组转集合,数组必须是引用数据类型的数组
List<int[]> list = Arrays.asList(arr);基本数据类型转集合会将这个数组当作对象存入集合
List<String> list = Arrays.asList(arr);
list.add("d"); 数组转集合是不能添加的



  jdk1.5的新特性可变参数
  自动拆装箱
  增强for循环
  泛型




HashMap和Hashtable
1,Hashtable是不能存储null键和null值的
  HashMap可以存储nuul键和null值
2,Hashtabl是jdk1.0版本,是线程安全的,效率低
HashMap是jdk1.2版本的,是线程不安全的,效率高




------- android培训、java培训、期待与您交流！ ----------