java字符串 – 那啥快看

Java里byte[] 和 String互相转换

方法一：String类转换

public static void main(String[] args) 
    {
        
        String string = "那啥快看 791202.com";
         
        //string 转 byte[]
        byte[] bytes = string.getBytes();
         
        //byte[]转string
        String s = new String(bytes);
        System.out.println("Decoded String : " + s);
    }

public static void main(String[] args)

{

String string = "那啥快看 791202.com";

//string 转 byte[]

byte[] bytes = string.getBytes();

//byte[]转string

String s = new String(bytes);

System.out.println("Decoded String : " + s);

}

方法二：Base64转换

public static void main(String[] args) 
    {
        
        byte[] bytes = "那啥快看 791202.com".getBytes();
         
        //byte[]转string
        String encoded = Base64.getEncoder().encodeToString(bytes);
         
        //string 转 byte[]
        byte[] decoded = Base64.getDecoder().decode(encoded);
         
       
        System.out.println( new String(decoded) );
    }

public static void main(String[] args)

{

byte[] bytes = "那啥快看 791202.com".getBytes();

//byte[]转string

String encoded = Base64.getEncoder().encodeToString(bytes);

//string 转 byte[]

byte[] decoded = Base64.getDecoder().decode(encoded);

System.out.println( new String(decoded) );

}

将java字符串写入txt文件方法总结

方法一

try {
	BufferedWriter out = new BufferedWriter(new FileWriter("那啥快看.txt"));
	out.write("791202.com");
	out.close();
	System.out.println("文件创建成功！");
} catch (IOException e) {
}

try {

BufferedWriter out = new BufferedWriter(new FileWriter("那啥快看.txt"));

out.write("791202.com");

out.close();

System.out.println("文件创建成功！");

} catch (IOException e) {

}

方法二

File f=new File("C:\\那啥快看.txt");
FileWriter fw;
try {
	fw=new FileWriter(f);
	String str="791202.com";
	fw.write(str);
	fw.close();
} catch (IOException e) { 
	e.printStackTrace(); 
}

File f=new File("C:\\那啥快看.txt");

FileWriter fw;

try {

fw=new FileWriter(f);

String str="791202.com";

fw.write(str);

fw.close();

} catch (IOException e) {

e.printStackTrace();

}

方法三

File f= new File("C:\\那啥快看.txt");
// 声明File对象
OutputStream out = null;
// 准备好一个输出的对象
out = new FileOutputStream(f);
// 通过对象多态性，进行实例化
String str = "791202.com";
// 准备一个字符串
byte b[] = str.getBytes();
// 只能输出byte数组，所以将字符串变为byte数组
out.write(b);
// 将内容输出，
out.close();

File f= new File("C:\\那啥快看.txt");

// 声明File对象

OutputStream out = null;

// 准备好一个输出的对象

out = new FileOutputStream(f);

// 通过对象多态性，进行实例化

String str = "791202.com";

// 准备一个字符串

byte b[] = str.getBytes();

// 只能输出byte数组，所以将字符串变为byte数组

out.write(b);

// 将内容输出，

out.close();

Java替换字符串方法总结

Java替换字符串有三种方法，分别是 replace()、replaceFirst() 和 replaceAll()。

replace() 方法

replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：

字符串.replace(String oldChar, String newChar)

其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar。

创建一个字符串，对它使用 replace() 方法进行字符串替换并输出结果。代码如下：

public static void main(String[] args) {
    String words = "hello java,hello php";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("replace(\"l\",\"D\")结果："+words.replace("l","D"));
    System.out.println("replace(\"hello\",\"你好\")结果："+words.replace("hello","你好 "));
    words = "hr's dog";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("replace(\"r's\",\"is\")结果："+words.replace("r's","is"));
}

public static void main(String[] args) {

String words = "hello java,hello php";

System.out.println("原始字符串是'"+words+"'");

System.out.println("replace(\"l\",\"D\")结果："+words.replace("l","D"));

System.out.println("replace(\"hello\",\"你好\")结果："+words.replace("hello","你好 "));

words = "hr's dog";

System.out.println("原始字符串是'"+words+"'");

System.out.println("replace(\"r's\",\"is\")结果："+words.replace("r's","is"));

}

输出结果如下所示：

原始字符串是’hello java,hello php’

replace(“l”,”D”)结果：heDDo java,heDDo php

replace(“hello”,”你好”)结果：你好 java,你好 php

原始字符串是’hr’s dog’

replace(“r’s”,”is”)结果：his dog

replaceFirst() 方法

replaceFirst() 方法用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串，其语法形式如下：

字符串.replaceFirst(String regex, String replacement)

其中，regex 表示正则表达式；replacement 表示用于替换的字符串。例如：

String words = "hello java，hello php";
String newStr = words.replaceFirst("hello","你好 ");
System.out.println(newStr); // 输出：你好 java,hello php

String words = "hello java，hello php";

String newStr = words.replaceFirst("hello","你好 ");

System.out.println(newStr); // 输出：你好 java,hello php

replaceAll() 方法

replaceAll() 方法用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串，其语法形式如下：

字符串.replaceAll(String regex, String replacement)

其中，regex 表示正则表达式，replacement 表示用于替换的字符串。例如：

String words = "hello java，hello php";
String newStr = words.replaceAll("hello","你好 ");
System.out.println(newStr); // 输出：你好 java,你好 php

String words = "hello java，hello php";

String newStr = words.replaceAll("hello","你好 ");

System.out.println(newStr); // 输出：你好 java,你好 php

两种方法进行Java字符串数组排序

本文将介绍两种方法进行Java字符串数组排序。

Java字符串数组排序方法A：使用compareTo（String）方法，还有compareToIgnoreCase(String) 忽略大小写

步骤：

1.compareTo(String)方法返回值是int类型的，如果字符串相等返回值为0，不相等则返回其他数值；
2.比较时是从第一个字符开始，依次比较对应字符的大小（ASCII码值），如果第一个字符和待比较字符串的第一个字符不等，则结束比较并返回他们之间的差值（ASCII码的差值）；
3.如果第一个字符相等,则继续比较后边的字符，直到比较完成。

代码：

public class StringArraySort {
	
	public static void main(String[] args) {
		String[] input=new String[] {"php","java","python","c++",".net"};
        String[] keys=arraySort(input);        
        for (String key : keys) {
            System.out.println(key);
        }
    }
	
	public static String[] arraySort(String[] input){       
        for (int i=0;i<input.length-1;i++){
            for (int j=0;j<input.length-i-1;j++) {
            	if(input[j].compareTo(input[j+1])>0){
                    String temp=input[j];
                    input[j]=input[j+1];
                    input[j+1]=temp;
                }
            }
        }
        return input;
    }
}

public class StringArraySort {

public static void main(String[] args) {

String[] input=new String[] {"php","java","python","c++",".net"};

String[] keys=arraySort(input);

for (String key : keys) {

System.out.println(key);

}

public static String[] arraySort(String[] input){

for (int i=0;i<input.length-1;i++){

for (int j=0;j<input.length-i-1;j++) {

if(input[j].compareTo(input[j+1])>0){

String temp=input[j];

input[j]=input[j+1];

input[j+1]=temp;

}

return input;

}

Java字符串数组排序方法B：通过如下的规则进行比较

步骤：

1.比较对应位置字母的ASCII码值的大小；
2.如果其中一个字符串的所有字符的ASCII码值都和另一个字符串相等，则直接比较字符串的长度，例如：abc<abcd。

代码：

public class StringArraySort {
	
	public static void main(String[] args) {
		String[] input=new String[] {"php","java","python","c++",".net"};
        String[] output=arraySort(input);        
        for (String out:output) {
            System.out.println(out);
        }
    }
	
	public static String[] arraySort(String[] input){       
        for (int i=0;i<input.length-1;i++){
            for (int j=0;j<input.length-i-1;j++) {
                if(isBiggerThan(input[j],input[j+1])){
                    String temp=input[j];
                    input[j]=input[j+1];
                    input[j+1]=temp;
                }
            }
        }
        return input;
    }
	
	/*如果first大于second，则返回true，否则返回false
	 * http://791202.com/
	 */
    private static boolean isBiggerThan(String first, String second){
        if(first==null||second==null||"".equals(first) || "".equals(second)){
            System.out.println("字符串不能为空！");
            return false;
        }        
        char[] arrayfirst=first.toCharArray();
        char[] arraysecond=second.toCharArray();        
        int minSize = Math.min(arrayfirst.length, arraysecond.length);        
        for (int i=0;i<minSize;i++) {
            if((int)arrayfirst[i]>(int)arraysecond[i]){
                return true;
            }else if((int)arrayfirst[i] < (int)arraysecond[i]){
                return false;
            }
        }
        if(arrayfirst.length>arraysecond.length){
            return true;
        }else {
            return false;
        }
    }
}

public class StringArraySort {

public static void main(String[] args) {

String[] input=new String[] {"php","java","python","c++",".net"};

String[] output=arraySort(input);

for (String out:output) {

System.out.println(out);

}

public static String[] arraySort(String[] input){

for (int i=0;i<input.length-1;i++){

for (int j=0;j<input.length-i-1;j++) {

if(isBiggerThan(input[j],input[j+1])){

String temp=input[j];

input[j]=input[j+1];

input[j+1]=temp;

}

return input;

}

/*如果first大于second，则返回true，否则返回false

* http://791202.com/

private static boolean isBiggerThan(String first, String second){

if(first==null||second==null||"".equals(first) || "".equals(second)){

System.out.println("字符串不能为空！");

return false;

}

char[] arrayfirst=first.toCharArray();

char[] arraysecond=second.toCharArray();

int minSize = Math.min(arrayfirst.length, arraysecond.length);

for (int i=0;i<minSize;i++) {

if((int)arrayfirst[i]>(int)arraysecond[i]){

return true;

}else if((int)arrayfirst[i] < (int)arraysecond[i]){

return false;

}

if(arrayfirst.length>arraysecond.length){

return true;

}else {

return false;

}

java集合转字符串

import org.apache.commons.lang.StringUtils;

List userList = new ArrayList<>();
//把集合转换成字符串
StringUtils.join(userList,”,”);

java如何截取字符串后几位

Java中的String类提供了一个substring(int from, int to)方法用于截取字符串中位置为from到to-1位置的字符。

因为字符串的字符位置是从0开始的，而substring(int from, int to)方法是前闭后开的，即[from, to)，可以理解为[from, to-1]。

同时to是可以省略的（多态），to缺省的情况下为截取到字符串的最后一位。

由此可以想到，java如何截取字符串后几位呢？

可以先获取字符串的长度，将字符串的长度-n作为substring()方法的第一参数，就能实现截取字符串最后的n个字符的效果。

String str = "i love 791202";
System.out.println(str.substring(str.length()-6)); // 791202

1 2	String str = "i love 791202"; System.out.println(str.substring(str.length()-6)); // 791202

另外要注意的是，Java中的String是不可变的类型，因此substring()方法并不会改变原字符串，而是返回了一个新的字符串。

System.out.println(str); // i love 791202

1	System.out.println(str); // i love 791202

java字符串转double

java字符串转double，注意可能会转换不成功，所以要捕获异常

try{
	String a1="1234";
	double b1=Double.valueOf(a1);
	double b2=Double.parseDouble(a1);
	System.out.println("b1 : "+b1+" "+"b2 : "+b2);
	}catch(NumberFormatException e){
	System.out.println("捕获转换异常："+e);
}
//        b1 : 1234.0 b2 : 1234.0

try{

String a1="1234";

double b1=Double.valueOf(a1);

double b2=Double.parseDouble(a1);

System.out.println("b1 : "+b1+" "+"b2 : "+b2);

}catch(NumberFormatException e){

System.out.println("捕获转换异常："+e);

}

// b1 : 1234.0 b2 : 1234.0

java定义字符串的两种方式的比较

大家都知道，java定义字符串有两种方式。

1.直接赋值

public class StringDemo{
	public static void main(String[] args) {
		String str1 = "791202.com";
		String str2 = "791202.com";
		String str3 = "791202.com";
		String str4 = "791202.cn";
		System.out.println(str1==str2);
		System.out.println(str1==str3);
		System.out.println(str2==str3);
		System.out.println(str1==str4);
	}
}

public class StringDemo{

public static void main(String[] args) {

String str1 = "791202.com";

String str2 = "791202.com";

String str3 = "791202.com";

String str4 = "791202.cn";

System.out.println(str1==str2);

System.out.println(str1==str3);

System.out.println(str2==str3);

System.out.println(str1==str4);

}

输出结果

true
true
true
false

true

false

2.构造方法实例化

public class StringDemo{
	public static void main(String[] args) {
	String str1 = new String("791202.com");
	String str2 = "791202.com";
	System.out.println(str1==str2);
	}
}

public class StringDemo{

public static void main(String[] args) {

String str1 = new String("791202.com");

String str2 = "791202.com";

System.out.println(str1==str2);

}

输出结果

false

false

两种方式的区别比较

第一种直接赋值定义

“==”虽然是一种字符串的比较，但是它实际上比较的并不是字符串的内容，而比较的是它们所在的内存地址的数值。可能会有疑惑，字符串的直接赋值，会产生一个新的堆内存空间，那么这里应该产生了三块堆内存空间，并且有不同的三个内存地址才对，但这里为什么会出现str1和str2和str3的内存地址是相同的呢？

第一种字符串的直接赋值方式，会给字符串赋予一个“名字”（其实就是堆内存的地址），并且开辟一段新的堆内存（存数据）。

那为什么这里会出现str1,str2,str3同时指向同一块堆内存？

因为JAVA有一个共享设计池（常量池）的概念

什么是共享设计模式？

在JVM底层实际会存在一个对象池，在用户通过直接赋值的方式定义了字符串时，这时候该字符串对应的匿名对象（在上述案例中就是791202.com和791202.cn，字符串常量就是对应的String类的匿名对象）自动“入池保存”，倘若后续过程中用户再次直接赋值定义了字符串并且还使用了相同的内容，那么将不再开辟新的堆内存，而是令其指向原来已经入池的对象进行引用。

因为字符串的值一旦设定将无法改变，因此，JAVA的设计者认为共享的设计方式，可以带来更高的效率。

第二种构造方法实例化

看到这里就已经很清楚构造方法实例化这种方式比较于直接赋值的缺陷所在，多开辟了一块堆内存，存在垃圾问题。

s1因为new关键字存在，就一定会去堆内存中开辟空间存放字符串，接着s2直接赋值定义字符串时，由于常量池存在，故不会创建新的字符串。我们说过==符号在用于引用数据类型时，比较的是两者的地址值，前者在堆内存中有指向，后者没有，因此结果会得到false。

总结

构造方法实例化字符串会存在一部分垃圾空间，便是堆内存中重复创建的字符串字段，因此直接赋值的方式确实优于构造方法的方式，因此字符串在使用时都使用的是直接赋值的方法。

Java读取输入的字符串代码

// Java读取输入的字符串代码
import java.util.*;
public class Main{
	public static void main(String []args){
		Scanner scanner = new Scanner(System.in);
		String a =scanner.next();//输入 ab cd ef
		String b =scanner.nextLine();//输入 ab cd ef
		System.out.println(a);//输出 ab
		System.out.println(b);//输出 ab cd ef
	}
}

// Java读取输入的字符串代码

import java.util.*;

public class Main{

public static void main(String []args){

Scanner scanner = new Scanner(System.in);

String a =scanner.next();//输入 ab cd ef

String b =scanner.nextLine();//输入 ab cd ef

System.out.println(a);//输出 ab

System.out.println(b);//输出 ab cd ef

}

next():只有读取到有效java字符串后才能结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。

nextLine():结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，其能得到带空格的字符串。

java字符串转16进制

/**
 * java字符串转16进制
 * @param s
 * @return
 */
public static String strTo16(String s) {
    String str = "";
    for (int i = 0; i < s.length(); i++) {
        int ch = (int) s.charAt(i);
        String s4 = Integer.toHexString(ch);
        str = str + s4;
    }
    return str;
}

/**

* java字符串转16进制

* @param s

* @return

public static String strTo16(String s) {

String str = "";

for (int i = 0; i < s.length(); i++) {

int ch = (int) s.charAt(i);

String s4 = Integer.toHexString(ch);

str = str + s4;

}

return str;

}