步骤1:先运行，看到效果，再学习
步骤2:模仿和排错
步骤3:TestArray
步骤 1 : 先运行，看到效果，再学习
老规矩，先下载下载区(点击进入)的可运行项目，配置运行起来，确认可用之后，再学习做了哪些步骤以达到这样的效果。
步骤 2 : 模仿和排错
在确保可运行项目能够正确无误地运行之后，再严格照着教程的步骤，对代码模仿一遍。
模仿过程难免代码有出入，导致无法得到期望的运行结果，此时此刻通过比较正确答案 ( 可运行项目 ) 和自己的代码，来定位问题所在。
采用这种方式，学习有效果，排错有效率，可以较为明显地提升学习速度，跨过学习路上的各个槛。
推荐使用diffmerge软件，进行文件夹比较。把你自己做的项目文件夹，和我的可运行项目文件夹进行比较。
这个软件很牛逼的，可以知道文件夹里哪两个文件不对，并且很明显地标记出来
这里提供了绿色安装和使用教程：diffmerge 下载和使用教程
步骤 3 : TestArray
package cn.how2j.test;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.util.Map;
import org.junit.Test;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Filter;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
public class TestArray {
@Test
@Comment("为空判断")
public void test1(){
int [] a = null;
int [] b = new int[5];
int [] c = new int[] {10,11,12};
p1("数组",Convert.toStr(a),"是否为空", ArrayUtil.isEmpty(a));
p1("数组",Convert.toStr(b),"是否为空", ArrayUtil.isEmpty(b));
p1("数组",Convert.toStr(c),"是否为空", ArrayUtil.isEmpty(c));
}
@Test
@Comment("调整数组大小")
public void test2(){
Integer [] a = new Integer[] {10,11,12};
Integer[] b = ArrayUtil.resize(a,5);
p3("调整大小前的数组", Convert.toStr(a) );
p3("调整大小后的数组", Convert.toStr(b) );
}
@Test
@Comment("合并数组")
public void test3(){
Integer [] a = {1,2,3};
Integer [] b = {10,11,12};
Integer [] c = ArrayUtil.addAll(a,b);
p2("合并前的两个数组 " ,Convert.toStr(a) + " , " + Convert.toStr(b), "合并后的数组是", Convert.toStr(c));
}
@Test
@Comment("克隆")
public void test4(){
Integer [] a = {1,2,3};
Integer b[]= ArrayUtil.clone(a);
p2("原数组",Convert.toStr(a), "克隆的数组", Convert.toStr(b));
}
@Test
@Comment("生成有序数组")
public void test5(){
p3("生成开始是0，结束是100，步长是9的有序数组", Convert.toStr( ArrayUtil.range(0, 100, 9)));
}
@Test
@Comment("过滤")
public void test6(){
Integer []a = {1,2,3,4,5,6,7,8,9};
Integer[] b = ArrayUtil.filter(a,new Filter<Integer>() {
@Override
public boolean accept(Integer t) {
if(0==t%3)
return true;
return false;
}
});
p2("原数组",Convert.toStr(a),"3的倍数过滤之后",Convert.toStr(b));
}
@Test
@Comment("转换为map")
public void test7(){
Integer a[] = {1,2,3};
String c[] = {"a","b","c"};
Map<Integer,String> m = ArrayUtil.zip(a, c);
p2("两个数组",Convert.toStr(a) + " , " + Convert.toStr(c),"转换为 Map ",m);
}
@Test
@Comment("是否包含某元素")
public void test8(){
Integer a[] = {1,2,3};
p1("数组", Convert.toStr(a),"是否包含元素3", ArrayUtil.contains(a, 3));
}
@Test
@Comment("装箱拆箱")
public void test9(){
int a[] = {1,2,3};
Integer b[] = ArrayUtil.wrap(a);
int c[] = ArrayUtil.unWrap(b);
p3("数组基本类型的装箱拆箱","ArrayUtil.wrap | ArrayUtil.unWrap");
}
@Test
@Comment("转换为字符串")
public void testa(){
int a[] = {1,2,3};
p3("数组转换为默认字符串", ArrayUtil.toString(a) );
p3("数组转换为自定义分隔符的字符串", ArrayUtil.join(a,"-" ));
}
@Test
@Comment("拆分")
public void testb(){
byte []a = {1,2,3,4,5,6,7,8,9};
byte[][] b=ArrayUtil.split(a, 2);
p3("数组被拆成2为长度的等份",Convert.toStr(a));
for (byte[] bs : b) {
p3("拆分后的数组：",Convert.toStr(bs));
}
}
private String preComment = null;
private void c(String msg) {
System.out.printf("\t备注：%s%n",msg);
}
private void p1(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format1");
}
private void p2(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format2");
}
private void p3(String type1, Object value1) {
p(type1, value1, "", "", "format3");
}
private void p(String type1, Object value1, String type2, Object value2, String format) {
try {
throw new Exception();
} catch (Exception e) {
String methodName = getTestMethodName(e.getStackTrace());
Method m =ReflectUtil.getMethod(this.getClass(), methodName);
Comment annotation = m.getAnnotation(Comment.class);
if(null!=annotation) {
String comment= annotation.value();
if(!comment.equals(preComment)) {
System.out.printf("%n%s 例子： %n%n",comment);
preComment = comment;
}
}
}
int padLength = 12;
type1=StrUtil.padEnd(type1,padLength,Convert.toSBC(" ").charAt(0));
type2=StrUtil.padEnd(type2,padLength,Convert.toSBC(" ").charAt(0));
if("format1".equals(format)) {
System.out.printf("\t%s的:\t\"%s\" %n\t被转换为----->%n\t%s的 :\t\"%s\" %n%n",type1,value1, type2, value2);
}
if("format2".equals(format)) {
System.out.printf("\t基于 %s:\t\"%s\" %n\t获取 %s:\t\"%s\"%n%n",type1,value1, type2, value2);
}
if("format3".equals(format)) {
System.out.printf("\t%s:\t\"%s\" %n\t%n",type1,value1);
}
}
private String getTestMethodName(StackTraceElement[] stackTrace) {
for (StackTraceElement se : stackTrace) {
String methodName = se.getMethodName();
if(methodName.startsWith("test"))
return methodName;
}
return null;
}
@Target({METHOD,TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Comment {
String value();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
