黑马训练营-学习笔记----JavaAPI

------- android培训、java培训、期待与您交流！
----------
 
String类是用于描述字符串事物的，那么它就提供了多个方法对字符串进行操作

常见的操作

"abcd"

1.获取

         1.1
字符串中包含的字符数，即字符串的长度    int length():获取长度

         1.2
根据位置获取位置上的某个字符   char charAt(int index):

         1.3
根据字符获取该字符在字符串中的位置  int indexOf(int ch):返回的

                 
是ch在字符串中第一次出现的位子，参数是ASCLL码类型，从开始位置索引

                  int indexOf(int ch,int fromIndex):从指定位置索引，获取ch的位置

 

                  int indexOf(String str);返回str在字符串中第一次出现的位置

                  int indexOf(String str,int fromIndex);从指定位置开始索引，获取str的位置

 

                  int lastIndexOf(int ch)  
反向索引

                  ........

2.判断

         2.1
字符串中是否包含某一个子串

                  boolean contains(str)

                 
特殊之处：indexOf(str):可以索引str第一次出现的位置，如

                 
果返回-1，表示不存在,所以也可以用于对指定字符串的判断是

                 
否包含，而且该方法既可以判断，又可以获取位置

         2.2
字符串中是否有内容

                  boolean isEmpty():就是判断长度是否为0

         2.3
字符串是否以指定内容开头

                  boolean startsWith(str)

         2.4
字符串是否以指定内容结束

                  boolean endsWith(str)

         2.5
判断字符串的内容是否相同，复写了Object类中的equals方法

                  boolean equals(str)

         2.6
判断内容是否相同，并忽略大小写

                  boolean equalsIgnoreCase();

3.转换

         3.1
将字符数组转成字符串

                 
构造函数：String(char[])

                                     String(char[],offset,count):将字符数组中的一

                                    
部分转成字符串,offset指起始位置，count表示要

                                    
转换的数目

                 
静态方法：static String copyValueOf(char[]);

                                     static String copyValueOf(char[] data,int offset,int count)

 

                                     static String valueOf(char[]):

         3.2
将字符串转成字符数组***

                  char[] toCharArray();

         3.3
将字节数组转成字符串

                  String(byte[])

                  String(char[],offset,count)

         3.4
将字符串转成字节数组

                  byte[] getBytes():

                         
特殊：字符串和字节数组在转换过程中是可以指定编码表的

         3.5
将基本数据类型转成字符串

4000
                  static String valueOf(int)

                  static String valueOf(double)

4.替换

         String replace(oldchar,newchar)

5.切割

         String[] split(regex);

6.子串。获取字符串中的一部分

         String substring(begin);

         String substring(begin,end)

 

StringBuffer是字符串缓冲区，是一个容器

        
长度可以变化

        
可以操作多个数据类型

        
最终会通过toString()方法变成字符串

1.存储

         StringBuffer append():将指定数据作为参数添加到已有数据的结尾处

         StringBuffer insert(index,数据）：可以将数据插入到指定index位上

2.删除

         StringBuffer delete(start,end)删除缓冲区中的数据，包含start，不包含end

         StringBuffer deleteCharAt(index):删除指定位置的数据

3.获取

         char charAt(int index)

         int indexOf(String str)

         int lastIndexOf(String str)

         int length()

         String sunstring(int start,int end)

4.修改

         StringBuffer replace(start,end,string)

         void setCharAt(int index),char ch)

5.反转

         StringBuffer reverse()

6.将缓冲区中的指定数据存储到指定数组中

         void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

JDK1.5版本后出现了StringBuilder

         StringBuffer是线程同步

         StringBuilder是线程不同步的

                 
开发建议使用StringBuilder,效率更高

 

java升级的单个因素

        
提高效率

        
简化书写

        
提高安全性

 

基本数据类型对象包装类

byte Byte

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

 

基本数据类型对象包装类的最常见作用就是用于基本数据类型和字符串之间的转换

        
基本数据类型转成字符串

                 
基本数据类型+""

                 
基本数据类型.toString(基本数据类型值）;

                 
如：Integer.toString(34);//将34整数变成"34"

        
字符串转成基本数据类型

                  xxx a = Xxx.parseXxx(String);

                  int a = Integer.parseInt("123");

                  double b = Double.parseDouble("12.23")

                  boolean b = Boolean.parseBoolean("true");//静态调用

                  Integer i = new Integer("123");//非静态调用

                  int num = i.intValue();

        
十进制转成其他进制

                  toBinaryString()

                  toHexString()

                  toOctalString()

        
其他进制转成十进制

                  parseInt(String,radix)

 

面向对象语言对事物的体现都以对象的形式，所以为了方便对多个对象的

        
操作，就对对象进行了存储，集合就是存储对象最常用的一种形式

 

数组虽然也是可存储对象的，但长度是固定的，集合长度是可变的，数组中

        
可以存储基本数据类型，集合只能存储对象

 

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象

 

Collection

         List:元素是有序的，元素可以重复，因为该集合体系有索引

                  ArrayList:底层的数据结构使用的是数组结构，特点在于查询速度很快

                         
但是增删稍慢；线程不同步

                  LinkedList：底层使用的是链表数据结构，特点就是增删较快，查询稍慢

                  Vector：底层是数组数据结构，线程同步，被ArrayList替代了

 

         Set：元素是无序的，元素不可以重复，没有索引

 

List：

        
特有方法，凡是可以操作角标的方法都是该体系特有的方法

        
增

                  add(index,element)

                  addAll(index,Collection)

        
删

                  remove(index)

        
改

                  set(index,element)

        
查

                  get(index)

                  subList(from,to)

                  listIterator()

 

List集合特有的迭代器，ListIterator是Iterator的子接口

        
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生

         ConcurrentModificationException异常

        
所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是

        
有局限的，只能对元素进行判断，取出，删除操作

        
如果想要其他的操作，如添加，修改等，就需要使用其子接口：ListIterator

                 
该接口只能通过List集合的ListIterator获取

 

Set:无序，不可以重复

         HashSet：数据结构是哈希表，线程是非同步的

                           保证元素唯一性的原理：判断元素的hashCode值是否相同

                           如果相同，还会继续判断元素的equals方法，是否为true

         TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树

                                  
保证数据唯一性的依据：compareTo方法return 0

                           TreeSet排序的第一种方式：让元素自身具备比较性，元素

                           需要实现Comparable接口，覆盖compareTo方法，这种方式

                           也称为元素的自然顺序，或者叫做默认顺序

 

                           TreeSet的第二种排序方式

                           当元素自身不具备比较性时，或者具备的比较性不是所需的

                           这时就需要让集合自身具备比较性

                           在集合初始化时，就有了比较方式

 

当元素自身不具备比较性，或者具备的比较性不是所需的，这时就需要让容器

        
自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时，以比较器为主

定以比较器：定义一个类，实现Comparator接口，覆盖compare方法

 

Set:元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复

         HashSet：底层数据结构是哈希表

                          HashSet是通过元素的两个方法，hashCode和equals来保证元素的唯一性

                         
如果元素的HashCode值相同，才会判断equals是否为true

                         
如果元素的HashCode值不同，不会调用equals

 

                         
注意：对于判断元素是否存在以及删除等操作，依赖的方法是元素的

                          HashCode和equals方法

         TreeSet：

 

Set集合的功能和Collection一致

 

LinkedList特有方法：

         addFirst();

         addLast();

         getFirst();

         getLast();

        
获取元素但不删除元素

         removeFirst();

         removeLast();

        
获取元素，但是会删除元素,如果集合中没有元素会出现

                  NoSuchElementException异常，

        
在JDK1.6出现了替代方法，如果集合中没有元素，会返回null

                  offsetFirst();

                  offsetLast();

                  peekFirst();

                  peekLast();

                  pollFirst();

                  pollLast()

 

Map集合：该集合存储键值时，一对一对往里存，而且保证键的唯一性

         1.添加

                  put(K key,V value)

                  putAll(Map<? extends k,? extends V> m)

         2.删除

                  clear()

                  remove(Object key)

         3.判断

                  containsValue(Object value)

                  containsKey(Object key)

                  isEmpty()

         4.获取

                  get(Object key)

                  size()

                  value()

 

                  entrySet()

                  KeySet()

 

Map:

         Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的

                                   JDK1.0,效率低

         HashMap：底层是哈希表数据结构，允许使用null键null值，该集合是不同步的

                                   JDK1.2,效率高

         TreeMap：底层是二叉树数据结构，线程不同步，可以用于该Map集合中的键排序

 

和Set很像

其实Set底层就是调用了Map

 

Map集合的两种取出方式：

         1.Set<k> KeySet:将Map中所有的键存入到Set集合，因为Set具备迭代器，所以可以

                                  
迭代取出所有的键，再根据get方法，取得每个键对应的值

 

                                   Map集合的取出原理：将Map集合转成Set集合，再通过迭代器取出

 

         2.Set<Map.Entry<k,v> entrySet：将map集合中的映射关系存入到了set集合中，而

                                  
这个关系的数据类型就是：Map.Entry

                                            Map.Entry其实Entry也是一个接口，它是Map接口中的一个内部接口

 

Arrays:用于操作数组的工具类，里面都是静态方法

 

asList:将数组变成list集合

*/

import java.util.*;

class ArraysDemo

{

         public static void main(String[] args)

         {

                  //把数组变成集合的好处就是可以使用集合的思想和方法来操作数组中的元素

                          //注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的

                                   //如果增删，会发生异常UnsupportedOperationException

                  String[] arr = {"abc","cc","tt"};

                  List<String> list = Arrays.asList(arr);

                  sop(list);

 

                  int[] nums = {2,4,5};

                  List<int[]> li = Arrays.asList(nums);

                  sop(li);

 

                  Integer[] num = {2,4,6};

                  List<Integer> lii = Arrays.asList(num);

                  /*

                 
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素

                 
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在          

                  */

                  sop(lii);

         }

         public static void sop(Object obj)

         {

                  System.out.println(obj);

         }

}

 

集合变数组

Collection接口中的toArray方法

 

import java.util.*;

class CollectionToArray

{

         public static void main(String[] args)

         {

                  ArrayList<String> al = new ArrayList<String>();

 

                  al.add("a1");

                  al.add("a2");

                  al.add("a3");

 

                  /*

                  1.指定类型的数组定义的长短

                         
当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组

                         
长度为集合的size；当指定类型的数组长度大于集合的size，那就不会创建数组

                         
而是使用传递进来的数组，所以创建一个刚好长度的数组最优

 

                  2.之所以要将集合变数组，是为了限定对元素的操作:不需要进行增删操作了

 

                  */

                  String[] arr = al.toArray(new String[al.size()]);

                  System.out.println(Arrays.toString(arr));

         }

}

 

高级for循环

格式：

for(数据类型变量名：被遍历的集合(Collection)或者数组)

{

}

对集合进行for遍历，只能获取集合中的元素，但不能对集合进行操作

迭代器除了遍历，还可以进行remove集合中元素的动作，如果是用ListIterator，

还可以在遍历过程中对集合进行增删改查的操作

 

传统for和高级for的区别：

高级for有一个局限性，即必须有被遍历的目标

建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义角标

 

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制

 

好处：

1.将运行时期出现的问题ClassCastException转移到了编译时期，方便与程

        
序员解决问题，让运行时期问题减少，安全

2.避免了强制转换的麻烦

 

泛型格式：通过<>定义要操作的引用数据类型

在使用java提供的对象时，什么时候使用泛型：只要见到<>就要定义泛型

        
其实<>就是用来接受类型的，的那个使用集合时，将集合中要存储的数据类

        
作为参数传递到<>中即可

 

泛型类定义的泛型在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作

        
的具体类型后，所有要操作的类型就固定了，为了让不同方法可以操作不同类型

        
，而且类型还不确定，那么可以将泛型定义在方法上

 

静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可

        
将泛型定义在方法上

 

当类中操作的引用数据类型不确定的时候，早期定义Object来完成扩展

        
现在定义泛型类来完成扩展

 

? 通配符，也可以理解为占位符

泛型的限定：

？extends E:可以接受E类型或者E的子类型，上限

？super E:可以接受E类型或者E的父类型，下限

 

 

 

 

 

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