黑马程序员---java基础---String类、泛型

来源：互联网发布：天正建筑软件学习编辑：程序博客网时间：2024/05/15 09:18

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

String

一、String概述

1.概述

1）final 不能复写，是一个类对象。

2）String s1 = "abc";
s1是一个类类型的变量，abc是对象。内存中只有一个变量。
String s2 = new String("abc");
s2内存中有两个对象。

String s3 = "abc";
内存中有一个对象。

s1==s2; //false
是不同的对象，所以为false

s1.equals(s2); //true
因为String中复写了equals方法，用于判断字符创相同。

s1==s3;//true
因为内存中已经有abc字符串，所以不会再在内存中创建。

常量池中已经存在就不会再耗费资源。指向s1对象。

  class StringDemo {public static void main(String[] args) {String s1 = "abc";//s1是一个类类型的变量，“abc”是一个对象                  //字符串最大的特点就是一旦被初始化就不能被改变//String s1 ="kk";  此时输出s1为kk，因为s1指示地址                  //由abc对象到kk对象发生变化String s2 = new String("abc");//s1与s2的区别//s1在内存中有一个对象，s2在内存中有两个对象System.out.println(s1==s2);//falseSystem.out.println(s1.equals(s2));//String  类复写了Object类中equals方法，               //true                 //该方法用于判断字符串是否相同}}

3）字符串特点

一旦被初始化就不可以被改变。

2.常见的操作方法

1）获取

获取长度

length（）注意字符串中是方法。而数组中获取长度是 .length

获取指定位置的字符

charAt（index）

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

indexOf（int ch）返回的是字符串中第一次出现该字符出现的位置

indexOf（int ch，int fromIndex）从fromIndex位置开始查找，ch出现的位置

反向索引

lastIndexOf（int ch）从右往左找

2）判断

字符串是否包含某一个子字符串 contains（str）

判断是否有内容 isEmpty（）

是否是以指定内容开头的 startsWith（str）

是否已以指定内容结尾 endsWith（str）

判断内容是否相同，复写Object中的equals方法 equals（str）

3）转换

字符数组转换成字符串

（1）构造函数 String（char[]）

String(char[] ,offset)

（2）静态方法 static void copyValue（char[]）

字符串转成字符数组

char[] toCharArray（）

字节数组转换成字符串

String(byte[]) String(byte[] ,offset,count) count指转换的个数

字符串转换成字节数组

byte[] getBytes()

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

valueOf（int） valueOf（double）

4）替换

replace（char old，char new）

5)切割

String[] split（regex）

6)子字符串

subString（begin） subString（begin，end）含头不含尾

7)转换
toUpperCase（） toLowerCase（）

8)去空格

trim（）两端去空格

9)对两个字符串进行自然排序

int compareTo(String)

 class StringMethodDemo{public static void main(String[] args) {/*String s1 = "abc";String s2 = new String("abc");String s3 = "abc";System.out.println(s1==s2);//falseSystem.out.println(s1==s3);//true   s3时发现abc已经存在则不再开辟内存*/                //所以相等        String str = "abcdjksjha.java";method_is(str);method_trants();method_replace();method_split();sub();compare();}public static void compare(){String s1 = "   abc java   ";String s2 = "abcjh";String s3 ="ahdk";sop(s1.toUpperCase());sop(s1.toLowerCase());sop(s2.compareTo(s3));}public static void sub(){ String s1 = "hdhuid"; sop(s1.substring(2)); sop(s1.substring(2,4));}public static void method_split(){String s1 = "diaolinan,wangming";String[] arr = s1.split(",");for(int i=0;i<arr.length;i++){sop(arr[i]);}}public static void method_replace(){String s1 = "hello java";String s2 = s1.replace('a','l');String s3 =s1.replace("java","world");sop("s1="+s1);sop("s2="+s2);}  public static void method_trants() {    char[] ch = {'a','b','c','d','e','f'};String s1 = new String(ch,2,4);sop(s1);String s2 = "hjhdkk";char[] arr = s2.toCharArray();for(int i=0;i<arr.length;i++){sop("arr="+arr[i]);} }  public static void method_is(String str)  {  sop(str.length());  sop(str.charAt(4));  sop(str.indexOf('a',4));  sop(str.lastIndexOf('b'));  sop(str.lastIndexOf('b',4));  sop(str.contains(".java"));  sop(str.startsWith("abc"));  sop(str.endsWith(".java"));    }    public static void sop(Object obj)   {System.out.println(obj);   }}class  StringTest{public static void main(String[] args) {String s1 = "  java  ";sop("("+s1+")");String s = Trim(s1);        sop("("+s+")");String s3 = "dhjsahd";sop(trants(s3));}        public static void sop(Object obj){System.out.println(obj);}//练习1  字符串去除空格public static String Trim(String str){int start = 0,end = str.length()-1;while(start<=end && str.charAt(start)==' ')start++;while(start<=end && str.charAt(end)==' ')end--;return str.substring(start,end+1);//包含头不包含尾}      //字符串反转   /*   将字符串转成数组   将数组反转   将数组转换成字符串   */   public static String trants(String str)   {char[] arr = str.toCharArray();char[] ch = new char[arr.length];        int i=0,j=str.length()-1;        while(j>=0)    {ch[i] = arr[j];i++;j--;    }String s = new String(ch,0,ch.length);return s;   }}

3.StringBuffer 线程安全的可变字符序列

字符串缓冲区，是一个容器，且长度不可变，可添加不同类型的数据

与数组的区别：数组也是容器，但只能存同以；类型的数据。并且长度不可以变。

1）常见操作增删改查

添加 append（str）

插入 insert(index,数据)

删除 delete（satrt，end）含头不含尾，删除缓冲区的数据

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

获取 charAt（index）获取指定位置的数据

indexOf（str）获取str第一次出现的位置

lastIndexOf(str) 反向索引

length（）获取长度

subString（str）获取子字符串

修改 replace（start，end，str）替换

void setChars(int srcbegin,int srcend，cahr[] dst,int dstbegin)

反转 reserve（）

4.StringBuilder

jdk1.5出现的字符串缓冲区

与StringBuffer的区别

StringBuffer：线程安全的可变字符序列

同步，有锁

StringBuilder：不同步，提高效率

5.jdk升级的因素：

提高效率，简化书写，提高安全性

二、基本数据类型

基本数据类型对应的类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

作用：进行转换

基本数据类型转换成String

基本数据类型.toString（值）

值+""

String转换成基本数据类型

1) 数据类型.parse数据类型（str）

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

2)int b = new Integer("123");

b,intValue();

三、进制进行转换

十进制转换成其他

二进制 toBinaryString（）

八进制 toHexString（）

十六进制 toOctalString（）

其他进制转换成十进制

parseInt（String,radix） radix 尾要转换的进制

四、jdk1.5后的新特性

1.书写

Integer x = 4; 进行自动装箱、

原 = new Integer(4);

x = x+2; x自动拆箱，转换成int、与2进行运算，再进行装箱赋值给x，可自动运算

注意：

Integer 有null值，所以当Integer为空时，会有异常出现，注意要进行判断

2.Integer m = 128;

Integer n = 128;

System.out.println(m==n); flase

原因：因为m与n是不同的对象

Integer a = 127;

Integer b = 127;

System.out.println(a==b); true a，b指向同一个对象

原因：因为当数值在byte范围内，对于新特性，如该数值已经存在，则不会开辟新的空间。

泛型

一、泛型概述

1.泛型

jdk1.5以后出现的新特性，用于解决安全问题，是一个类型安全机制。

2.好处

1）将运行时期出现的问题转移到了编译时期。方便程序员进行解决问题。

让运行时期问题减少，更安全。

2）避免了强制转换麻烦

3.泛型的使用

泛型格式

通过<>来定义要操作的引用数据类型

在使用java提供的对象时，什么时候写泛型：

通常在集合框架中很常见，只要看到<>就要定义泛型，

其实<>就是用来接收类型的。当使用集合时，

将集合中要存储的数据类型作为参数传递到<>中即可。

//泛型接口

interface Inter<T>{void show(T t);}/*class InterImpl implements Inter<String>{public void show(String t){System.out.println("show:"+t);}}*/class InterImpl<T> implements Inter<T>{public void show(T t){System.out.print("show:"+t);}}class  GenericDemo5{public static void main(String[] args) {InterImpl<Integer> i = new InterImpl<Integer>();i.show(4);}}

4.泛型类

什么时候定义泛型类？

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

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

 class  Utils<QQ>     {            private QQ q;           public void setObject(QQ q)          {              this.q = q;           }           public QQ getObject()          {                return q;           }      }

5.泛型的方法

泛型类定义的泛型在真个类里是有效的，如果北方法调用，

那么泛型类的对象明确要操作的具体类型之后，

所有要操作的类型已经固定。

为了让不同方法可以操作不同类型，但类型不确定。

那么可以将泛型定义在方法上。

 /*泛型类、泛型方法、静态方法泛型*/class Demo<T>{public <T> void show(T t){System.out.println("T:"+t);}public <T> void print(T t){System.out.println("print:"+t);}public static <T> void method(T t){System.out.println("method"+t);}}class GeneticDemo3 {public static void main(String[] args) {   /*    若show与print方法不是泛型方法，则有如下使用方法   Demo<String> s = new Demo<String>();s.show("hsjhk");s.print("aaaaaaa");        此处若为s.print(new Integer(5));则会出错因为s已经指定为String类型Demo<Integer> in = new Demo<Integer>();in.show(new Integer(7));in.print(0);*/Demo<String> d = new Demo<String>();d.show("aaaaa");d.print(new Integer(5));//直接打印int类型也可以，因为是泛型方法Demo.method("hello");//可用类直接调用，因为metho是静态方法泛型   /*   注意：<T>要写在返回类型前面，修饰符后面。   上述class Demo中方法上的<T>可不同，也可相同。   */}}

6.静态方法泛型

特殊之处

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，

可以将泛型定义在方法上。

calss Demo<T>

{

public static <T> void print(T t)

{

System.out.println(t);

}

7.泛型接口

interface Inter<T>

{

void show(T t);

}

如何实现泛型接口

class In <T> implements Inner<T>

//泛型接口interface Inter<T>{void show(T t);}/*class InterImpl implements Inter<String>{public void show(String t){System.out.println("show:"+t);}}*/class InterImpl<T> implements Inter<T>{public void show(T t){System.out.print("show:"+t);}}class  GenericDemo5{public static void main(String[] args) {InterImpl<Integer> i = new InterImpl<Integer>();i.show(4);}}

8.泛型限定

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

泛型的占定：

1）？ extends E ：可以接受E类型或者E的子类型。上限

2） ? super E：可接受E类型或者E的父类型。下限

import java.util.*;class GenericDemo6 {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");ArrayList<Integer> al1 = new ArrayList<Integer>();al1.add(1);al1.add(2);al1.add(3);        print(al);print(al1);}    public static void print(ArrayList<?> al){Iterator<?> it = al.iterator();while(it.hasNext()){System.out.println(it.next());}}}

import java.util.*;class  GenericDemo7 {public static void main(String[] args) {System.out.println("Hello World!");}}class Person{private String name;private int age;public String getName(){return name;}public void setName(String name){this,name = name;}}class Student  extends Person{    public int getName(){super(name);}}