前言

java 关于操作数据的api中大多是如题目的两种形式，例如：



public static char[] copyOfRange(char[] original, int from, int to)



public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

以前就知道关于(begin, end)的参数是截头不截尾的。

char[] chars = {'a', 'b', 'c', 'd'};
Arrays.copyOfRange(chars, 1,3); 

会返回字符数组{‘b’, ‘c’} 

返回的数组长度为 end - begin ==> 2 

而(off, len)代表从off处截取len个长度的数组 

实际截取的长度为len 

例如：

char[] chars = {'a', 'b', 'c', 'd'};
char[] cy = new char[5];
System.arraycopy(chars, 1, cy, 1, 3); 

得么的cp字符数组应该是{‘b’, ‘c’, ‘d’, ‘\u0000’, ‘\u0000’} 

实际截取了3个长度



关于越界问量的思考

以前在使用这样的方法时，超级害怕越界问题，每次都瓣着手指头算半天，今天算是开窍了。

如果是（begin, end)这样的参数，只需要判断： 

end >  srcArr.length就可以， 如果该条件为真，则肯定会发生越界

如果是(off, len)这样的参数，只需要判断： 

off + len > srcArr.length, 如果该条件为真，则肯定会发生越界

二者之间的换算问题

（begin, end) 换算成  (off, len)

off = begin
len = end - begin

(off, len) 换算成  (begin, end)



begin = off
end = off + len



总结

别嫌我笨，咱们还能愉快的玩耍 

如果这样换算出错了，提刀来见我（我肯定剁了你<- _ -!>)

以前用JAVA比较少，没怎么留意
随着现在用Java的频率越来越高，一些不起眼的小问题也会让人捉摸一下，当然了要养成良好的习惯，遇到问题先去看API。
这可是多少前辈的经验啊。
话不多说，进入正题。
	其实这个东西并不难，Java提供现成的API实现两者的转换，在这里写下就是加强一下记忆。
	1) String转换为char[] :
			String str = "abcd";
			char[] temp;
			temp = str.toCharArray();
	2) char[]转换为String : 
			char[] temp = { 'a' , 'b' , 'c' , 'd '};
			有两种方法可以进行转换
			1、str = new String( temp);  //实际调用的是String的一个构造函数  String(char[] value)
			2、str = String.valueOf( temp);   //实际调用的是String类的一个方法
 

Java API对Arrays类的说明是：此类包含用来操作数组（比如排序和搜索）的各种方法。
1.对基本数据类型的数组的排序
说明：
(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;
(2)比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。
(3)要对基础类型的数组进行降序排序，需要将这些数组转化为对应的封装类数组，如Integer[]，Double[]，Character[]等，对这些类数组进行排序。(其实还不如先进行升序排序，自己在转为将序)。
用默认的升序对数组排序
函数原型：static void sort(int[] a)   对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a, int fromIndex, int toIndex)  对指定 int 型数组的指定范围按数字升序进行排序。　
代码实例：
[url=]复制代码[/url]代码如下:
import java.util.Arrays;
public class ArraysSort_11 {
public static void main(String args[])
{
int[] a={1,4,-1,5,0};
Arrays.sort(a);
//数组a[]的内容变为{-1,0,1,4,5}
for(int i=0;i<a.length;i++)
System.out.print(a+"  ");
}
}
2.对复合数据类型的数据的排序
函数原型：
(1)public static<T> void sort(T[] a，Comparator c)  根据指定比较器产生的顺序对指定对象数组进行排序。
(2)public static<T> void sort(T[] a，int fromIndex，int toIndex，Comparator c)  根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。　
说明：这个两个排序算法是“经过调优的合并排序”算法。
代码实例：
[url=]复制代码[/url]代码如下:
package aa;
import java.util.Arrays;
import java.util.Comparator;
public class Arraysort {
Point[] arr;
Arraysort(){
    arr=new Point[4];    //定义对象数组arr，并分配存储的空间
    for(int i=0;i<4;i++)
        arr=new Point();
}

public static void main(String[] args) {

    Arraysort sort=new Arraysort();
    sort.arr[0].x=2;sort.arr[0].y=1;    //初始化，对象数组中的数据
    sort.arr[1].x=2;sort.arr[1].y=2;
    sort.arr[2].x=1;sort.arr[2].y=2;
    sort.arr[3].x=0;sort.arr[3].y=1;

    Arrays.sort(sort.arr, new MyComprator());    //使用指定的排序器，进行排序
    for(int i=0;i<4;i++)    //输出排序结果
        System.out.println("("+sort.arr.x+","+sort.arr.y+")");
}
}
class Point{
int x;
int y;
}
//比较器，x坐标从小到大排序；x相同时，按照y从小到大排序
class MyComprator implements Comparator {
public int compare(Object arg0, Object arg1) {
Point t1=(Point)arg0;
Point t2=(Point)arg1;
if(t1.x != t2.x)
return t1.x>t2.x? 1:-1;
else
return t1.y>t2.y? 1:-1;
}
}
转载于:https://blog.51cto.com/14314113/2391344

在本文中，我们将向您展示几种在Java中将String类型的字符串字母倒序的几种方法。
StringBuilder(str).reverse()
char[]循环与值交换
byte循环与值交换
apache-commons-lang3
如果是为了进行开发，请选择StringBuilder(str).reverse()API。出于学习的目的，我们可以研究char[]和byte方法，其中涉及到值互换和移位运算技术，这些技术对于了解StringBuilder(str).reverse()API黑匣子背后原理非常有帮助。
1. StringBuilder(str).reverse()
在Java中，我们可以使用StringBuilder(str).reverse()使字符串字母倒序。
public class ReverseString1 {

    public static void main(String[] args) {

        String str = "Reverse a String in Java";

        StringBuilder sb = new StringBuilder(str).reverse();

        System.out.println(sb.toString());

    }
}
输出结果
avaJ ni gnirtS a esreveR
2.char[]
首先，我们将字符串转换为char数组，并逐个循环char数组，并使用temp变量交换值。
public class ReverseString2 {

    public static void main(String[] args) {

        String str = "Hello World";
        System.out.println(reverse(str));         //  dlroW olleH

    }

    public static String reverse(String input) {

        if (input == null || input.length() < 0)
            throw new IllegalArgumentException("Please provide an input!");

        char[] result = input.toCharArray();

        int startIndex = 0;
        int endIndex = result.length - 1;
        char temp;

        for (; endIndex > startIndex; startIndex++, endIndex--) {
            temp = result[startIndex];
            result[startIndex] = result[endIndex];
            result[endIndex] = temp;
        }

        return new String(result);
    }

}
上面的算法需要5个循环（长度/ 2）来使字符串倒序“ Hello World”。
------------------------------------
H  e  l  l  o     W  o  r  l  d
------------------------------------
0  1  2  3  4  5  6  7  8  9  10
------------------------------------

Loop #1 - Swap index 0 <-> index 10
------------------------------------
{d}  e  l  l  o     W  o  r  l  {H}
------------------------------------
{0}  1  2  3  4  5  6  7  8  9  {10}
------------------------------------

Loop #2 - Swap index 1 <-> index 9
------------------------------------
d  {l}  l  l  o     W  o  r  {e}  H
------------------------------------
0  {1}  2  3  4  5  6  7  8  {9}  10
------------------------------------

Loop #3 - Swap index 2 <-> index 8
------------------------------------
d  l  {r}  l  o     W  o  {l}  e  H
------------------------------------
0  1  {2}  3  4  5  6  7  {8}  9  10
------------------------------------

Loop #4 - Swap index 3 <-> index 7
------------------------------------
d  l  r  {o}  o     W  {l}  l  e  H
------------------------------------
0  1  2  {3}  4  5  6  {7}  8  9  10
------------------------------------

Loop #5 - Swap index 4 <-> index 6
------------------------------------
d  l  r  o  {W}     {o}  l  l  e  H
------------------------------------
0  1  2  3  {4}  5  {6}  7  8  9  10
------------------------------------
3. Byte[] – StringBuilder(str).reverse(str)
以下代码段类似于StringBuilder(str).reverse()的内部实现（UTF16内容除外）。
import java.nio.charset.StandardCharsets;

public class ReverseString3 {

    public static void main(String[] args) {

        String str = "Hello World";
        System.out.println(reverse(str));

    }

    public static String reverse(String input) {

        if (input == null || input.length() < 0)
            throw new IllegalArgumentException("Please provide an input!");

        byte[] val = input.getBytes(StandardCharsets.UTF_8);
        int length = val.length - 1;

        for (int start = (length - 1) >> 1; start >= 0; start--) {
            int end = length - start;
            byte temp = val[start];
            val[start] = val[end];
            val[end] = temp;

            // debugging
            //System.out.println(String.format("start=%s, end=%s", start, end));
        }

        return new String(val);
    }

}
最令人困惑的部分是右移运算符(length - 1) >> 1，这是什么意思？查看下面的8位示例，您可以找到规律吗？
System.out.println(10>>1);  //  10 -> 5
0000 1010   = 10
0000 0101|0 = 10 >> 1 = 5

System.out.println(4>>1);   //  4 -> 2
0000 0100   = 4
0000 0010|0 = 4 >> 1 = 2

System.out.println(100>>1); //  100 -> 50
0110 0100   = 100
00110 010|0 = 100 >> 1 = 50

System.out.println(7>>1);   //  7 -> 3
0000 0111   = 7
0000 0011|1 = 7 >> 1 = 3
对于数字，每右移1位，金额将减少该值的一半并四舍五入。这(length - 1) >> 1试图找出字符串的中间点。
number >> 1 = round_down(number/2) or Math.flooa(number/2)
值交换从内部开始，然后扩展到外部。
for (int start = (length - 1) >> 1; start >= 0; start--) {
    int end = length - start;
    byte temp = val[start];
    val[start] = val[end];
    val[end] = temp;
}
上面的算法图示如下：
------------------------------------
H  e  l  l  o     W  o  r  l  d
------------------------------------
0  1  2  3  4  5  6  7  8  9  10
------------------------------------

Loop #1 - Swap index 4 <-> index 6
------------------------------------
H  e  l  l  {W}     {o}  o  r  l  d
------------------------------------
0  1  2  3  {4}  5  {6}  7  8  9  10
------------------------------------

Loop #2 - Swap index 3 <-> index 7
------------------------------------
H  e  l  {o}  W     o  {l}  r  l  d
------------------------------------
0  1  2  {3}  4  5  6  {7}  8  9  10
------------------------------------

Loop #3 - Swap index 2 <-> index 8
------------------------------------
H  e  {r}  o  W     o  l  {l}  l  d
------------------------------------
0  1  {2}  3  4  5  6  7  {8}  9  10
------------------------------------

Loop #4 - Swap index 1 <-> index 9
------------------------------------
H  {l}  r  o  W     o  l  l  {e}  d
------------------------------------
0  {1}  2  3  4  5  6  7  8  {9}  10
------------------------------------

Loop #5 - Swap index 0 <-> index 10
------------------------------------
{d}  l  r  o  W     o  l  l  e  {H}
------------------------------------
{0}  1  2  3  4  5  6  7  8  9  {10}
------------------------------------
4. Apache commons-lang3
对于Apache commons-lang3库，我们可以使用StringUtils.reverse反转字符串和StringUtils.reverseDelimited反转单词。
pom.xml
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.10</version>
</dependency>
import org.apache.commons.lang3.StringUtils;

public class ReverseString3 {

    public static void main(String[] args) {

        System.out.println(StringUtils.reverse("Hello World Java"));                // reverse string

        System.out.println(StringUtils.reverseDelimited("Hello World Java", ' '));  // reverse words

    }
}
输出结果
avaJ dlroW olleH

Java World Hello
查看其源代码，Apache-commons-lang3其实是使用new StringBuilder(str).reverse()来反转字符串。
package org.apache.commons.lang3;

  public class StringUtils {

  public static String reverse(final String str) {
      if (str == null) {
          return null;
      }
      return new StringBuilder(str).reverse().toString();
  }

  //...
}
欢迎关注我的博客，里面有很多精品合集
本文转载注明出处（必须带连接，不能只转文字）：字母哥博客。
觉得对您有帮助的话，帮我点赞、分享！您的支持是我不竭的创作动力！ 。另外，笔者最近一段时间输出了如下的精品内容，期待您的关注。 
《手摸手教你学Spring Boot2.0》
《Spring Security-JWT-OAuth2一本通》
《实战前后端分离RBAC权限管理系统》
《实战SpringCloud微服务从青铜到王者》
《VUE深入浅出系列》