黑马程序员_JavaAPI上

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

 

        String概述：

字符串特点：字符串是一个特殊的对象。字符串一旦初始化就不可以被改变。

String s1="abc"; String s2=new String("abc"); s1和s2有什么区别？

s1在内存中只有一个对象。s2在内存中有两个对象。

String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。常见的操作如：

1.获取。

1.1获取字符串中包含的字符数，也就是字符串的长度。方法： int length();

1.2根据位置获取该位置上的某个字符。方法： char charAt(int index);

1.3根据字符获取该字符在字符串中的位置。

方法： int indexOf(int ch);（返回的是ch在字符串中第一次出现的位置）

              int indexOf(int ch,int fromIndex);（从fromIndex指定位置开始，获取ch在字符串中第一次出现的位置）

              int indexOf(String str);

              int indexOf(String str,int fromIndex);

              int lastIndexOf(int ch);（反向索引字符第一次出现的位置）

2.判断。

2.1字符串中是否包含某一个子串。方法： boolean contains(String str);

2.2字符串中是否有内容。方法： boolean isEmpty();

2.3字符串是否是以指定内容开头。方法： boolean startsWith(String str);

2.4字符串是否是以指定内容结尾。方法： boolean endsWith(String str);

2.5判断字符串内容是否相同。方法： boolean equals(String str);（覆盖了Object类中的equals方法）

2.6判断内容是否相同，并忽略大小写。方法： boolean equalsIgnoreCase(String str);

特殊之处：indexOf(String str)可以索引字符串第一次出现的位置。如果返回-1；表示该字符串不在字符串中存在。所以，该方法也可以用于对指定的字符串判断是否包含。而且该方法既可以判断，又可以获取字符串出现的位置。

3.转换。

3.1将字符数组转成字符串。

构造函数方法：String(char[] data)

                            String(char[] data,int offset,int count)（将字符数组的一部分转成字符串。offset：起始位置。count：要转的字符个数。）

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

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

                    static String valueOf(char[] data);

3.2将字符串转成字符数组。方法：char[] toCharArray();

3.3将字节数组转成字符串。

方法：String(byte[] data);

            String(byte[] data,int offset,int count);

3.4将字符串转成字节数组。方法：byte[] getBytes();

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

方法：static String valueOf(int);

            static String valueOf(double);

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

4.替换。方法：String replace(oldchar,newchar);

5.切割。方法：String[] split(regex);（regex：切割符。不会打印出来。）

6.获取子串。

方法：String substring(int begin);

            String substring(int begin,int end);（包含开始，不包含结尾）

7.转换，去除空格，比较。

7.1将字符串转成大写或者小写。

方法：String toUpperCase();（转成大写）

            String toLowerCase();（转成小写）

7.2将字符串两端的多个空格去除。方法：String trim();

7.3对两个字符串进行自然顺序的比较。方法：int compareTo(String str);

 

StringBuffer（字符缓冲区）：字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删。StringBuffer是一个容器，很多方法与String相同。StringBuffer是可变长度的。

StringBuffer特点：

1.长度是可变化的。

2.可以直接操作多个数据类型。

3.最终会通过toString方法变成字符串。

StringBuffer对数据进行操作：

1.存储。

方法：StringBuffer append()：将指定数据作为参数添加到已有数据结尾处。

            StringBuffer insert(int index,数据)：可以将数据插入到指定的角标位置。

2.删除。

方法：StringBuffer delete(int start,int end)（包含开始，不包含结尾）

            StringBuffer deleteCharAt(int index)：删除指定角标位置的字符。

3.获取。

方法：char charAt(int index);

            int indexOf(String str);

            int lastIndexOf(String str);

            int length();

            String substring(int start,int end);

4.修改。

方法：StringBuffer replace(int start,int end,String str);

            void setCharAt(int index,char ch);

5.反转。方法：StringBuffer reverse();

6.将缓冲区中的指定数据存储到指定字符数组中。方法：void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)（srcBegin：原数据开始处。srcEnd：原数据结尾处。dstBegin：在字符数组中起始存储处。）

 

JDK1.5版本之后出现了StringBuilder。

StringBuilder和StringBuffer的区别：StringBuffer是线程同步的。StringBuilder是线程不同步的。

以后开发，建议使用StringBuilder，因为效率较高。

注：Java升级三因素：

1.提高效率。

2.简化书写。

3.提高安全性。

 

基本数据类型包装类

基本数据类型：byte short int long boolean float double char

基本数据类型包装类：Byte Short Integer Long Boolean Float Double Character

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

基本数据类型转成字符串：

1.基本数据类型+"";

2.基本数据类型.toString(基本数据类型值);如：Integer.toString(35);//将35整数转成"35"。

字符串转成基本数据类型：xxx a=Xxx.parseXxx(String);

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

        double b=Double.parseDouble("12.43");

        boolean d=Boolean.parseBoolean("false");

基本数据类型包装类JDK1.5版本之后的新特性：

Integer x=new Integer(4);可简写为：Integer x=4;

 

集合框架概述

集合类出现的原因：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合的不同：

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

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

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

集合框架的构成及分类：

 

定义这么多集合的原因：因为集合其实就是容器。而每一个容器对数据的存储方式都不同。这个存储方式称之为：数据结构。

集合类的共性方法：

1.添加元素：add(Object obj);

2.获取集合长度：size();

3.删除元素：remove(Object obj);

4.清空集合：clear();

5.判断元素：contains(Object obj);//判断集合是否包含该元素。

                       isEmpty();//判断集合是否为空。

迭代器：其实就是集合的取出元素的方式。把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内的元素，那么取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容：判断和取出。那么可以将这些共性内容抽取，就是Iterator（迭代器）。

如何获取集合的取出对象？

通过一个对外提供的方法iterator()。

 

Collection

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

         |------Set：元素是无序的，元素不可以重复。

List集合特有的方法：

1.增：add(index ,element);

           add(index,Collection);

2.删：remove(index);

3.改：set(index,element);

4.查：get(index);

           subList(start,end);

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

在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发操作异常。所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法有限的。如果想要其他的操作如：添加，修改等，就需要使用其子接口：ListIterator。该接口只能通过List集合的listIterator方法获取。

Collection

         |------List

              |------ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢。线程不同步。

              |------LinkedList：底层使用的是链表数据结构。线程不同步。特点：增删速度很快，查询稍慢。

              |------Vector：底层是数组数据结构。线程同步。被ArrayList替代。支持枚举。

注：枚举是Vector特有的取出方式。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

LinkedList特有的方法：

addFirst();

addLast();

获取元素，但不删除元素：getFirst();

                                                getLast();

获取元素，但是删除元素：removeFirst();

                                                removeLast();

 

Collection

        |--------Set：元素是无序的，元素不可以重复。

              |--------HashSet：底层数据结构是哈希表。线程是非同步的。

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

HashSet保证元素唯一性的原理：

是通过元素的两个方法：hashCode方法和equals方法来完成。如果元素的哈希地址值相同，才会判断元素内容是否相同。如果元素的哈希地址值不同，不会判断元素内容。如果元素的哈希地址值相同，元素内容相同，视为元素重复，则该元素不会存入HashSet集合。

TreeSet保证元素唯一性的原理：compareTo方法。

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也称之为元素的自然顺序，或者叫默认顺序。

示例1：

import java.util.*;
class TreeSetDemo
{
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet();
  ts.add(new Student("wanglin01",20));
  ts.add(new Student("wanglin09",23));
  ts.add(new Student("wanglin07",19));
  ts.add(new Student("wanglin05",19));
  ts.add(new Student("wanglin01",20));
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   Student stu=(Student)it.next();
   System.out.println(stu.getName()+"::"+stu.getAge());
  }
 }
}
class Student implements Comparable
{
 private String name;
 private int age;
 Student(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public int compareTo(Object obj)
 {
  if(!(obj instanceof Student))
   throw new RuntimeException("不是学生对象");
  Student s=(Student)obj;
  System.out.println(this.name+".....compareto...."+s.name);
  if(this.age>s.age)
   return 1;
  if(this.age==s.age)
   return this.name.compareTo(s.name);
  return -1;
 }
 public String getName()
 {
  return name;
 }
 public int getAge()
 {
  return age;
 }
}

TreeSet排序的第二种方式：当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

注：当两种排序方式都存在时，以比较器为主。

示例2：

import java.util.*;
class Student implements Comparable
{
 private String name;
 private int age;
 Student(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public int compareTo(Object obj)
 {
  if(!(obj instanceof Student))
   throw new RuntimeException("不是学生对象");
  Student s=(Student)obj;
  //System.out.println(this.name+".....compareto...."+s.name);
  if(this.age>s.age)
   return 1;
  if(this.age==s.age)
   return this.name.compareTo(s.name);
  return -1;
 }
 public String getName()
 {
  return name;
 }
 public int getAge()
 {
  return age;
 }
}
class TreeSetDemo3
{
 public static void main(String[] args)
 {
  TreeSet ts=new TreeSet(new MyCompare());
  ts.add(new Student("wanglin01",20));
  ts.add(new Student("wanglin09",23));
  ts.add(new Student("wanglin07",19));
  ts.add(new Student("wanglin05",19));
  ts.add(new Student("wanglin005",16));
  ts.add(new Student("wanglin09",28));
  ts.add(new Student("wanglin01",20));
  Iterator it=ts.iterator();
  while(it.hasNext())
  {
   Student stu=(Student)it.next();
   System.out.println(stu.getName()+"::"+stu.getAge());
  }
 }
}
class MyCompare implements Comparator
{
 public int compare(Object o1,Object o2)
 {
  Student s1=(Student)o1;
  Student s2=(Student)o2;
  int num=s1.getName().compareTo(s2.getName());
  if(num==0)
   return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
  return num;
 }
}

 

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------