final修饰和StringBuffer的几个案例（拼接，反转，对称操作）

final关键字修饰时如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但引用变量不能变，引用变量所指向的对象中的内容还是可以改变的

final 与static final修饰变量区别

final修饰的值是可以改变内容不能改变引用地址。static fina修饰的因为它是static，在装载时已被初始化，而不是每次创建新对象时都初始化。所以内容也不可以改变

常用static final同时修饰一些常量

StringBuffer的几个案例

1、
　　把数组拼接成一个字符串

 1 public class StringBufferTest2 {

 2

 3 public static void main(String[] args) {

 4 //定义一个数组

 5 int[] arr = {12,21,33,9,2};

 6

 7 //方式1：定义功能，使用String做拼接

 8 String s1 = arrayToString(arr);

 9 System.out.println("String拼接的方法："+s1);

10

11 //方式2：定义功能能，使用StringBuffer做拼接

12 String s2 = arrayToString2(arr);

13 System.out.println("StringBuffer拼接的方法："+s2);

14

15 }

16

17 public static String arrayToString(int[] arr) {

18 //定义一个[的字符串

19 String s = "[";

20 //进行数组的遍历以及转换为字符串

21

22 for(int x=0;x<arr.length;x++){

23 if(x == arr.length-1){

24 s += arr[x]+"]";

25 }

26 else{

27 s += arr[x]+",";

28 }

29 }

30 return s;

31 }

32

33 public static String arrayToString2(int[] arr) {

34

35 //定义一个"["的StringBuffer的缓冲区

36 StringBuffer sb = new StringBuffer();

37 sb.append("[");

38

39 //进行数组的遍历，以及转换为StringBuffer缓冲区

40 for(int x=0;x<arr.length;x++){

41 if(x == arr.length-1){

42 sb.append(arr[x]);

43 }

44 else{

45 sb.append(arr[x]).append(",");

46 }

47 }

48 sb.append("]");

49 //StringBuffer 转换成 String

50 return sb.toString();

51 }

52 }

2、
　　把字符串反转

 1 import java.util.Scanner;

 2 public class StringBufferTest3 {

 3

 4 public static void main(String[] args) {

 5 Scanner sc = new Scanner(System.in);

 6 System.out.println("请输入想要反转的数据");

 7 String str = sc.nextLine();

 8

 9 //调用方法1 reverse1

10 String result = reverse1(str);

11 System.out.println("反转后的数据："+result);

12

13 //调用方法2 reverse2

14 String result2 = reverse2(str);

15 System.out.println("反转后的数据："+result2);

16 }

17

18 //方式1：用String的方法

19 public static String reverse1(String s){

20

21 //定义一个[的字符串

22 String s1 = "";

23

24 //把字符串转成数组

25 char[] ch = s.toCharArray();

26

27 //进行数组的元素遍历以及字符串的拼接

28 for(int x = ch.length-1;x >= 0;x--){

29

30 if(x == 0){

31 s1 += ch[x];

32 }

33 else{

34 s1 += ch[x];

35 }

36 }

37 return s1;

38 }

39

40 //方式2，利用StringBuffer的反转方法

41 public static String reverse2 (String s){

42

43 //把输入的String类型转换为StringBuffer类型

44 //StringBuffer buffer = new StringBuffer(s);

45

46 //进行StringBuffer的反转功能：

47 //public StringBuffer reverse()

48 //return buffer.reverse().toString();

49

50 //简洁版

51 return new StringBuffer(s).reverse().toString();

52 }

53

54 }

3、
　　判断一个字符串是否是对称字符串
　　　　分析：
　　　　　　两种方法可以完成：
　　　　　　A：用string来完成：
　　　　　　　　先把字符串改成数组，再对里面的数据进行，一个一个地对比，最后的和第一个，倒二和第二....
　　　　　　B：用StringBuffer来完成：
　　　　　　　　直接倒转来对比原值
　　　　　　C:分别创建方法，两个必须确认的值：
　　　　　　　　　　　　　　　　a：返回类型：boolean
　　　　　　　　　　　　　　　　b：参数列表：String

 1 import java.util.Scanner;

 2 public class StringBufferTest4 {

 3

 4 public static void main(String[] args) {

 5 //创建键盘输入

 6 Scanner sc = new Scanner(System.in);

 7 System.out.println("请输入你想要判断的字符串：");

 8 String str = sc.nextLine();

 9

10 //调用第一种方法

11 boolean b1 = symmetry1(str);

12 System.out.println("这个字符串是否对称："+b1);

13

14 //调用第一种方法2

15 boolean b2 = symmetry2(str);

16 System.out.println("这个字符串是否对称："+b2);

17

18 //调用第二种方法

19 boolean b3 = symmetry2(str);

20 System.out.println("这个字符串是否对称："+b3);

21 }

22

23 //方式1：用string的方法来一个一个对比

24 public static boolean symmetry1(String s){

25 //把字符串改成数组

26 char[] c = s.toCharArray();

27 //进行比较，定义2个变量：start和end，分别从两端开始对比

28 for(int start = 0, end = c.length-1;start < end ; start ++,end--){

29 if(c[start] != c[end]){//进行判断

30 return false;

31

32 }

33 }

34 return true;

35 }

36

37 //方式1的另外一种方式：

38 public static boolean symmetry2(String s){

39 //定义一个boolean值

40 boolean flog = true;

41

42 //把字符串改成数组

43 char[] c = s.toCharArray();

44

45 //进行比较，定义2个变量：start和end，分别从两端开始对比

46 for(int start = 0, end = c.length-1;start < end ; start ++,end--){

47 if(c[start] != c[end]){//进行判断

48 flog = false;

49 break;

50 }

51 }

52 return flog;

53 }

54

55 //方式2 利用StringBuffer的反转功能

56 public static boolean symmetry3(String s){

57 return new StringBuffer(s).reverse().toString().equals(s);

58 //先从String变为StringBuffer类型，再对它进行反转，再变回string类型，再让此时得到的字符串与原来的对比里面的数据是否一样

59 }

60 }

巴特西

final修饰和StringBuffer的几个案例（拼接，反转，对称操作）

最新文章

热门文章