5月16号 编码解码

编码解码

字节码和字符串的转换

package day1.stringdemo;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;public class Stringdemo5 { 
public static void main(String[] args) throws UnsupportedEncodingException {  
//抛出一个错误  throws UnsupportedEncodingExceptio       
String s= "中国";       
//"utf-8,用utf-8这个编码表进行编码解码，此外还有GBK编码表       
byte [] b=s.getBytes("utf-8");//编码，将字符串转为字节码        System.out.println(Arrays.toString(b));    

//出现乱码问题是由于编码和解码用的不是同一个编码表（编码方式不同）   
String s1= new String(b,"utf-8");//解码，将字节码转为字符串  
System.out.println(s1);        //解码时可以对指定区间进行操作，offset：开始位置        
String s2= new String(b,3,3,"utf-8");        
System.out.println(s2);       

//char[]   tochar Array()     
String s3="中文";       
char [] d= s3.toCharArray();//，字符串转为数组       
Arrays.sort(d);//sort，排序       
System.out.println(Arrays.toString(d));    }}

String s =“中国”;

byte [ ] b =s.get Bytes( ); 编码

string s1=new Stirng( b)； 解码

byte [ ] b =s.get Bytes(“GBK” ); 不同的编码表

byte [ ] b =s.get Bytes(“utf-8” ); 系统默认

Reaplace 替换功能

String s=“ abccdefg ”；

String s1=s.replace(“cc”,“CC”)；

String s1=s.replace(“要被替换的元素，字符串”,“新的元素，字符串”)；

sout （s1）；

sout （ s1.length（））；

sout （s.trim*(s.length())）;取出字符串前后（首尾）的空格

**replace ** 全部替换

replaceAll 全部替换,当要被替换的元素有多个时，搜有的都被替换

replaceFirst 当要被替换的元素有多个时，只有第一个被替换

区别:r

eplace的参数是char和CharSequence,即可以支持字符的替换,

也支持字符串的替换(CharSequence即字符串序列的意思,说白了也就是字符串);
replaceAll的参数是regex,即基于规则表达式的替换,

比如,可以通过replaceAll("\d", “*”)把一个字符串所有的数字字符都换成星号;

正则表达式

正则表达式（规则） 是一种字符串模式匹配语言（一种判断）

返回值为 true 或者false

matchs(" ");

判断字符串s中是否包含“a"这个元素

String s=“abc”；

boolean res= s.matchs(“a”);

sout (res);

\d 数字 匹配0-9的数字（由于java语言中\表示转义符，\d要写成\\d,其他的也是同理）

\d [13456] 这个数字是在13456这几个中的一个

\\d ？ 这个数字在字符串中出现一次或者一次都没有

\\d * 这个数字在字符串中出现0次或者多次

\\d + 这个数字在字符串中出现1次或者多次

\\d {n} 这个数字在字符串中恰好出现n次

\\d {n,m} 这个数字在字符串最少出现n次，最多出现m次

package day1.stringdemo;public class StringDemo6 { 
public static void main(String[] args) {    
//正则表达式，（规则）  是一种字符串模式匹配语言   
String s= "as";        
boolean res= s.matches("a");      
System.out.println(res);    

/*  . 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

        X? X，一次或一次也没有
        X* X，零次或多次
        X+ X，一次或多次
        X{n} X，恰好 n 次
        X{n,} X，至少 n 次
        X{n,m} X，至少 n 次，但是不超过 m 次

        X|Y X 或 Y
*/

String s1= "123535";
boolean res1= s1.matches("1");
System.out.println(res1); 

//d？表示只有一个数字或者没有数字
boolean res2= s1.matches("\\d?");
//java语言中要将\d写成\\d,以、因为其中一个\ 表示转译符
System.out.println(res2);//d？表示只有一个数字或者没有数字  

//d+表示只有一个数字或者多个数字
boolean res3= s1.matches("\\d+");
//d+表示只有一个数字或者多个数字
System.out.println(res3);

 //d{n},长度     
 boolean res4= s1.matches("\\d{5}");
 //d{}表示恰好出现5个数字     
 System.out.println(res4);       
 
 //d{n，m},长度       
 boolean res5= s1.matches("\\d{1,5}");
 //d{1,5}表示最少出现1个数字，最少出现5个数字     
 System.out.println(res5);      
 
 //表示数字是在1到3之间        
 boolean res6= s1.matches("[1-5]");    
 System.out.println(res6);       
 
 //表示第一个出现的是1，第二个数是在1到3之间取一个数字，接下来的长度为4，总长度为6     
 boolean res7= s1.matches("1[1-3]\\d{4}");    
 System.out.println(res7);       
 
 //d+表示只有零个数字或者多个数字   
 boolean res8= s1.matches("\\d*");    
 System.out.println(res8);       
 
 //表示在1235中取一个数字      
 boolean res9= s1.matches("[1235]");    
 System.out.println(res9);    }}

package day1.stringdemo;
public class StringDemo7 {   

/*  . 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9
]\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]      

X? X，一次或一次也没有    
X* X，零次或多次     
X+ X，一次或多次      
X{n} X，恰好 n 次     
X{n,} X，至少 n 次    
X{n,m} X，至少 n 次，但是不超过 m 次   
X|Y X 或 Y*/    


public static void main(String[] args) {     
boolean  a= "1314aDAAa@qq163.com.cn".matches("\\w{9,12}@\\w{5,8}\\.(com\\.cn)");         System.out.println(a);//   ture    
//   \s 空格 有空格返回ture，否则为false     
boolean b= "    ".matches("\\s+");      
System.out.println(b);          

//   \D     非数字，只要不是数字就为ture   
boolean c= "   ds ".matches("\\D+");   
System.out.println(c);      

//   \S非空格  大写S  有空格返回false，否则为ture   
boolean d= "    ".matches("\\S+");        
System.out.println(d);      

//   \w   单词字符（英文字母，数字）   数字可以转化为字符    
boolean e= "12ds".matches("\\w{3,9}");      
System.out.println(e);       

//   \W  大写W   非单词字符     
boolean f= "@#￥%%？》》   ".matches("\\W{3,12}");     
System.out.println(f);     }
}

StringBuffer和StringBuilder

String ：String用final修饰，值不可以改变，除非新建一个对象

StringBuffer：线程安全的，值可以改变的字符串

StringBuilder：线程不安全的，值可以改变的字符串

StringBuffer s=new StringBuffer（“adaf1244fsf”）；

新建了一个16个字节的字符串，底层是一个char数组

StringBuffer s1=s.append(“xxx”);从StringBuffer s的后面插入元素

StringBuffer s1=s.insert( 位置,“xxx”);从StringBuffer ,从指定位置插入元素

StringBuffer s1=sdelete(0,5);删除StringBuffer s的指定区间的元素,包含开始,不包含结尾

StringBuffer s1=s.reserve();将StringBuffer s逆序

StringBuffer s1=(s.replace(0,5),“xxx”);从StringBuffer s的指定位置替换元素

package day1.stringbufferdemo;
public class BufferDemo1 {  


public static void main(String[] args) {    
// String  Buffer 线程安全的，值可变的字符串   
// String  Builder 线程不安全的，值可变的字符串   

StringBuffer s= new StringBuffer("abcdefg");//创建一个字符串对象，底层是一个char数组    
/*public StringBuffer(String str) {     
super(str.length() + 16);         
append(str);        }*/  

s.append("132462");//从后面插入   
s.insert(3,"345");//从指定位置插入     
System.out.println(s);///输出结果为  abc345defg132462  
s.delete(0,5);//删除指定区间的字符串，包含开始，不包含结尾  
System.out.println(s);///输出结果为  5defg132462      
//在指定区间，用指定的字符串替代原区间的字符       

/*替换功能         s.replace(" old","new")     
s.replaceFirst(" old","new")      
s.replaceAll(" old","new")       
s.replace(start:开始位置 ,end:结束位置 ,str:值 )        */ 
System.out.println(s.replace(0,3,"qwe"));//输出结果为  qwefg132462    
String  s1=new String(s);      
System.out.println(s1);   


StringBuffer s2= s.reverse();
 System.out.println(s2);
}
}

Math

Math是一个类，里面包含很多静态方法，通过类名可以直接调用

Math.sart(m); 平方根

Math.pow(n,m); n的m次方

Math.abs(a); 绝对值

Math.radom();随机数，大于0小于1.0

max

min

package day1.stringbufferdemo;
import java.util.Arrays;
import java.util.Random;public class MathDemo { 

public static void main(String[] args) {    
/*abs 绝对值       
sqrt 平方根       
pow(double a, double b) a的b次幂   
max(double a, double b)    
min(double a, double b)      
random() 返回 0.0 到 1.0 的随机数   
long round(double a) double型的数据a转换为long型（四舍五入）    

Random类       Random类概述 此类用于产生随机数 ，构造方法     

public Random()       
l 成员方法        
public int nextInt()      
public int nextInt(int n)*/  

System.out.println(Math.abs(6));  
System.out.println(Math.floor(6.1));    
System.out.println(Math.sqrt(4));    
System.out.println(Math.max(2,3)); 
System.out.println(Math.ceil(6));  
System.out.println(Math.min(6,3));     

//Random  随机数        Random r= new Random();    
System.out.println(r.nextInt());//负二十一亿到正二十一亿之间随机获取一个数        System.out.println(r.nextInt(33));//1-32之间随机获取一个数        System.out.println(r.nextInt(33)+1);//1-33之间随机获取一个数        System.out.println(r.nextLong());     

byte []b= new byte[5];     
r.nextBytes(b);    //byte最大值为127 ，-128-127        System.out.println(Arrays.toString(b));//随机生成一个数组b    }}

Radom随机数

Radom r =new Radom（）；

sout（r.nextInt()）；

sout（r.nextInt(33)）;0-32之间随机取一个值

sout（r.nextInt(33)+1）;1-33之间随机取一个值

sout(r.nextLong());

byte b=new byte [10];新建一个长度为10的byte类型的数组

r.nextBytes(b);随机给这个数组赋值

sout(Arrays.toString(b))

//Random 随机数

​ Random r= new Random();
System.out.println(r.nextInt());//负二十一亿到正二十一亿之间随机获取一个数 System.out.println(r.nextInt(33));//1-32之间随机获取一个数

System.out.println(r.nextInt(33)+1);//1-33之间随机获取一个数 System.out.println(r.nextLong());

byte []b= new byte[5];
r.nextBytes(b); //byte最大值为127 ，-128-127

/Random 随机数

​ Random r= new Random();
System.out.println(r.nextInt());//负二十一亿到正二十一亿之间随机获取一个数 System.out.println(r.nextInt(33));//1-32之间随机获取一个数

System.out.println(r.nextInt(33)+1);//1-33之间随机获取一个数 System.out.println(r.nextLong());

byte []b= new byte[5];
r.nextBytes(b); //byte最大值为127 ，-128-127

System.out.println(Arrays.toString(b));//随机生成一个数组b }}