黑马程序员——java基础---常用API

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

一、String类

  概念:String类代表字符串。Java 程序中的所有字符串字面值("abc")都作为此类的实例实现。又因为该类被final修饰,表明它不能被其它类所继承,其下的一系列关于字符串的操作方法也就无法被复写。

  特点:字符串一旦被创建,将无法改变其值。

 1 public class StringTest {
 2
 3     public static void main(String[] args) {
 4         String s1 = "abc";
 5         s1 = "cba";
 6         System.out.println(s1);
 7     }
 8
 9 }
10
11 //运行结果:cba

   上面结果原因:因为String为引用对象,所以String s1 = "abc"执行后,是建立一个索引指向"abc"的内存,接着s1 = "cba"执行,是将原先指向"abc"的索引重新指向了"cba",所以结果才会是"cba",但是内存中关于"abc"这个值却始终没有改变。

 1 public class StringTest {
 2
 3     public static void main(String[] args) {
 4         String s1 = "abc";
 5         String s3 = new String("abc");
 6         System.out.println(s1 == s3);
 7         System.out.println(s1.equals(s3));
 8     }
 9
10 }
11 /**
12  * 运行结果:
13  * false
14  * true
15  */

    上面结果原因:s3创建时会先去常量池中找"abc",然后建立一个新的存储"abc"的对象,然后由s3指向新建的对象。而s1指向的是常量池中的"abc",所以s1=s3返回false;如果这样来说,那么s1.equals(s3)也应该返回false,因为equals()方法比较的是内存的地址,这是应为String类对equals()方法进行了复写,它在String类中实现的效果是比较两个地址中的内容是否相同。

  因为String类用来描述字符串类事物,所以他提供了多种对字符串进行操作的方法:

  1、获取

               length():返回的是字符串的长度,也就是字符串中包含的字符个数

               charAt(int index):返回的是字符串中某个位置(index)上的字符

               indexOf(int ch):返回字符(ch)在字符串中第一次出现的索引。如果字符串中没有该字符,就返回-1。它还有其它的重载方法,最终都是为了返回字符串中某个字符的索引。
代码:

package filetools;

public class StringTest {

    public static void main(String[] args) {
        String s1 = "abc";
        System.out.println(s1.length()+"\r"+s1.charAt(1)+"\r"+s1.indexOf(‘b‘));
    }

}
/**
 * 运行结果:
 * 3
 * b
 * 1
 */


     2、判断
              contains(String str) :判断字符串中是否包含某一个子串。

          isEmpty() :判断字符串中是否有内容。原理就是判断长度是否为0。""和 null 不一样,""是一个对象, null 是指向空。

           startsWith(String str):判断字符串是否是以指定内容开头。

           endsWith(String str):判断字符串是否是以指定内容结尾。

         equals(String str): 判断字符串内容是否相同。复写了Object类中的equals方法。

        equalsIgnoreCase(String str):判断内容是否相同,并忽略大小写。

代码:

 1 public class StringTest {
 2
 3     public static void main(String[] args) {
 4         String s1 = "abcdefg";
 5         boolean b1 = s1.contains("de");
 6         boolean b2 = s1.isEmpty();
 7         boolean b3 = s1.startsWith("ab");
 8         boolean b4 = s1.endsWith("fg");
 9         boolean b5 = s1.equals("abcd");
10         boolean b6 = s1.equalsIgnoreCase(s1.toUpperCase());
11         System.out.println("b1 = "+ b1);
12         System.out.println("b2 = "+ b2);
13         System.out.println("b3 = "+ b3);
14         System.out.println("b4 = "+ b4);
15         System.out.println("b5 = "+ b5);
16         System.out.println("b6 = "+ b6);
17     }
18
19 }
20 /**
21  * b1 = true
22  * b2 = false
23  * b3 = true
24  * b4 = true
25  * b5 = false
26  * b6 = true
27  */

  3、转换

      构造方法:

        public String(char[] value): 将字符数组转成字符串

             public String(char[] value,int offset,int count): 将字符数组中的一部分转成字符串。

           toCharArray(): 将字符串转换为字符数组。


          构造方法:

            public String(byte[] byter): 将指定字节数组转成字符串。

                 public String(byte[] byter,int offset,int count): 将字节数组中的一部分转成字符串。

            getBytes(): 将字符串转成字节数组。

            valueOf(int i): 将基本数据类型转成字符串。重载方法没有byte和short类型,它们会自动提升为int型。 注意:也可以用+" "的方法转换。


  
4、替换
          replace(char oldchar,char newchar):通过用newChar替换字符串中所有oldChar。如果要替换的字符不存在,返回的还是原串。

代码:
                 
  5、切割
          split(String regex) :返回的是一个字符串数组,数组中元素是被分割的字符串。 
  
  6、子串
          substring(int beginIndex):返回一个新的字符串,从指定位置开始到结尾。
          substring(int beginIndex,int endIndex):返回一个新字符串,包含开始,不含结尾。

代码:

 1 public class StringTest {
 2
 3     public static void main(String[] args) {
 4         String s1 = "abcdcfc";
 5         //替换
 6         System.out.println(s1.replace("bcd", "dcb"));
 7         //切割
 8         String[] str = s1.split("c");
 9         for(String s : str)
10         System.out.print(s+"  ");
11         System.out.println();
12         //子串
13         System.out.println(s1.substring(2));
14         System.out.println(s1.substring(2, 5));
15
16     }
17
18 }
19 /**
20  * 运行结果:
21  * adcbcfc
22  * ab  d  f
23  * cdcfc
24  * cdc
25  */

        
  
7、其它
          toUpperCase() :将此 String 中的所有字符都转换为大写
          toLowerCase() :将此 String 中的所有字符都转换为小写
          trim(): 返回字符串的副本,忽略前部空白和尾部空白。如果没有空白返回的还是这个字符串。 
          compareTo(String anotherString):比较两个字符串。如果参数字符串等于此字符串,则返回0;如果此字符串按字典顺序小于字符串参数,则返回一个负数;否则则返回一个正数。
            compareToIgnoreCase(String str):忽略大小写后,进行比较,类似上一个方法。

代码:

 1 public class StringTest {
 2
 3     public static void main(String[] args) {
 4         String s1 = "abcdcfc";
 5         //toUpperCase()
 6         System.out.println(s1.toUpperCase());
 7         //toLowerCase()
 8         System.out.println("AJSHD".toLowerCase());
 9         //trim()
10         System.out.println(("  " + s1 +"   " + "sdkfj" + "  ").trim()+"ddd");
11         //compareTo()
12         System.out.println(s1.compareTo("abcdcf"));
13     }
14
15 }
16 /**
17  * 运行结果:
18  * ABCDCFC
19  * ajshd
20  * abcdcfc   sdkfjddd
21  * 1
22  */

二、StringBuffer类

  概念:线程安全的可变字符序列。一个类似于String的字符串缓冲区,但不能修改。String类中字符串一旦赋值,便不能修改。StringBuffer类是可以通过方法调用对其中的字符串进行修改。

  特点:

    1、长度可变。
       2、可操作多种数据类型。
       3、可用toString方法转化成字符串。

  注意:StringBuffer sb = new StringBuffer();  StringBuffer sb1 = sb.append(data); 执行过后 sb == sb1。

  常用的方法:

  1、存储

        append(datatype data) :在StringBuffer末尾添加上制定类型的数据。
          insert(int index,data) :在指定的位置(index)插入制定的数据(data)。

  2、删除

        delete(int start,int end): 删除StringBuffer中指定范围内的数据,不含start,含end。

      deleteCharAt(int index): 删除StringBuffe中指定位置(index0的字符。

    3、获取

      charAt(int index) 
          indexOf(String str) 
          lastIndexOf(String str) 
          length() 
          substring(int start)
          substring(int start, int end) 

    以上方法的用法和String类中用法一样,只不过操作对象由String换成了StringBuffer。

          toString() :返回StringBuffer中数据的字符串表示形式。

   4、修改

       setCharAt(int index, char ch): 将指定位置(index)处的字符设置为字符(ch)。

       replace(int start,int end,String str):将指定的字符串(str)换到调用对象的指定位置。包含start,不含end。

   5、反转。
          reverse():将调用对象中的数据头尾倒置。
    
  6、转存
       getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):将StringBuffer中指定位置的数据转存储到指定字符数组中的指定位置。含befin不含end。
       

代码:

 1 public class StringBufferTest {
 2
 3     public static void main(String[] args) {
 4         StringBuffer sb = new StringBuffer();
 5
 6         System.out.println(sb == sb.append("sadfjhkgjh"));
 7         System.out.println(sb.insert(2,"ttt"));
 8         System.out.println(sb.delete(2, 4));
 9         System.out.println(sb.deleteCharAt(3));
10         sb.setCharAt(1, ‘p‘);
11         System.out.println(sb);
12         System.out.println(sb.reverse());
13
14         char[] ch = sb.toString().toCharArray();
15         sb.getChars(2,5, ch, 3);
16         for(char c : ch)
17             System.out.print(c);
18     }
19
20 }
21 /**
22  * 运行结果:
23  * true
24  * satttdfjhkgjh
25  * satdfjhkgjh
26  * satfjhkgjh
27  * sptfjhkgjh
28  * hjgkhjftps
29  * hjggkhftps
30  */

三、StringBuilder

  Stringbuilder是JDK1.5版本后出现的,其作用和StringBuffer类似。

  不同点:StringBuffer支持线程同步,StringBuilder不支持线程同步。

  优点:

    1、提高效率  

    2、简化书写  

    3、提高安全性

  我们可以在单线程时使用Stringbuffer,多线程时使用Stringbuilder。

四、基本数据类型的包装类

  概念:基本数据类型分别包装后的对象类。

     如:int--Integer;

         long--Long;

         short--Short;

       byte--Byte;

       char--Character;

       float--Float;

         double--Double;

       boolean--Boolean;

   作用:通过将基本数据包装成类对象,可以通过方法调用来完成数据类型间的转化以及数据对象的其它操作。

   针对包装类,JDK1.5后出现的新特性:自动装箱和自动拆箱

    如:Integer x = 23;//自动装箱:将基本数据类型自动装箱成对象。

      x = x + 4;//自动拆箱:当x与4相加时,会自动变成基本类型,而当其和赋值给x时,又会自动装箱成对象。

    因为包装后已经属于对象了,所以会多出一个null值。

    注意:Integer m = 128;

       Integer n = 128;

          m == n;//false

       Integer a = 127;

       Integer b = 127;

         a == b;//true

   出现这样的结果是因为:当数值在byte的范围内,对于新特性,如果该数值已经存在于内存中,将不会为新对象开辟空间,而是将其指向已有的对象。

       

时间: 2024-10-22 14:32:02

黑马程序员——java基础---常用API的相关文章

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正

黑马程序员——Java基础---集合框架工具类

黑马程序员——Java基础<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java为操作Set.List和Map提供了一系列工具类,主要有Collections和Arrays.这两个工具类的特点:类中的方法都是静态的,不需要创建对象,直接使用类名调用即可.Collections:是集合对象

黑马程序员——java基础---IO(input output)流字符流

黑马程序员——java基础---IO(input output)流字符流 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- io(input output)流特点: 1,io流用来处理数据之间的传输 2,java对数据的操作是通过流的方式: 3,java用于操作流的对象都在io包中: 4,流按操作数据分为两种:字节流和字符流: 5,流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象

黑马程序员——java基础——反射

 黑马程序员--java基础--反射 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 反射 其实就是动态加载一个指定的类,并获取该类中的所有的内容.而且将字节码文件封装成对象,并将字节码文件中的内容都封装成对象,这样便于操作这些成员. 反射就是把Java类中的各种成分映射成相应的java类. 简单说:反射技术可以对一个类进行解剖. 反射的基石-->Class类 1.java中的类是用来描述一类事物的共性,该类事物有什么属性,没有什么属性

黑马程序员——java基础——集合(Collection)

 黑马程序员--java基础--集合(Collection) ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 集合框架的构成及分类,如下图: 1.为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 2.数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的:集合长度是可变的.数组中可以存储基本数据类型,集合只能存储对象. 3.

黑马程序员--java基础学习笔记5

黑马程序员--java基础学习笔记6 一.笔记内容概述: 数组-第二种定义格式.数组-常见操作-遍历-最值-选择排序-冒泡排序-排序位置置换代码提取.数组-排序的性能问题.数组-常见功能-查找-折半查找.进制转换-查表法-整合. 二.常用内容介绍: 1.数组初始化的三种方式: int[] arr = new int[3]; int[] arr = new int[]{1,2,3}; int[] arr = {1,2,3}; 2.查表法: 如果数据中出现了对应关系,而且对应关系的一方是有序的数字编

黑马程序员——Java基础---io(上)

黑马程序员——Java基础---io(上) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java I/O系统负责处理程序的输入和输出,I/O类库位于java.io包中,它对各种常见的输入流和输出流进行了抽象.如果数据流中最小的数据单元是字节,那么称这种流为字节流:如果数据流

黑马程序员——Java基础知识之多线程协同

多线程协同 线程间的通讯:对资源的操作动作不同,比如说两个卡车一个拉煤一个装煤,但是他们共享了一个资源. 怎么样把这个资源拿出来?怎样把车装满?这个资源当然是一个类,他里面的组成元素就是对象!!现在我们就要有操作对象的思想了,用对象把这车装满,现在一车装一个对象. 等待唤醒机制: 用的不是sleep是wait.flag标记,这是两人沟通的方式.其实每个标记就要做一次等待或者notify,判断wait,改值notify.线程池.notify唤醒里面的线程,按顺序唤醒.wait和notify必须用在

黑马程序员——java基础——多线程

 黑马程序员--java基础--多线程 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 进程:是一个正在执行中的程序.每一个进程执行都有一个执行顺序.该顺序是一个执行路径,或者叫一个控制单元. 线程:就是进程中的一个独立的控制单元.线程在控制着进程的执行.一个进程中至少有一个线程. 一个进程至少有一个线程在运行,当一个进程中出现多个线程时,就称这个应用程序是多线程应用程序,每个线程在栈区中都有自己的执行空间,自己的方法区.自己的变量.