16进制转字符串转成byte[]数组

public static byte[] stringTobytes(String hexString) {
    String stringProcessed = hexString.trim().replaceAll("0x", "");    stringProcessed = stringProcessed.replaceAll("\\s+", "");    byte[] data = new byte[stringProcessed.length() / 2];    int i = 0;
    for(int j = 0; i <= stringProcessed.length() - 1; i += 2) {
        byte character = (byte)Integer.parseInt(stringProcessed.substring(i, i + 2), 16);        data[j] = character;        ++j;    }

    return data;}

//byte转换16进制字符串

public static final String bytesToHexString(byte[] bArray) {
    StringBuffer sb = new StringBuffer(bArray.length);    String sTemp;    for (int i = 0; i < bArray.length; i++) {
        sTemp = Integer.toHexString(0xFF & bArray[i]);        if (sTemp.length() < 2)
            sb.append(0);        sb.append(sTemp.toUpperCase());    }
    return sb.toString();}

国际化语言设置

在下面中 local是国家代码, region是地区代码. region可有可无.比如汉语的话可能有繁体,跟简体.这种时候就需要region的代码了.在国际化语言设置的时候 这个可以根据 values当中的国际化语言参考设置.比如 values-ex-rMX. 这个是 西班牙的墨西哥语言. 所以 local就成了 es(西班牙), region成为了
mx(南美语).

        Locale locale = new Locale(local, region);
            Configuration config = new Configuration();            config.locale = locale;            App.getAppContext().getResources().updateConfiguration(config, App.getAppContext().getResources().getDisplayMetrics());

除了这个再看看 java中日期的国际化设置.

也是很简单.都是使用 Locale的.

但需要注意的是 比如你想对 月进行国际化翻译的话 'MMM'.一般是2个M,但如果是3个M的话

他就会翻译成国际化的语言.比如JUN

Locale locale = new Locale(language, countryCode);

SimpleDateFormat fromFormat = new SimpleDateFormat("yyyyMMdd");SimpleDateFormat newFormat  = new SimpleDateFormat("yyyyMMMdd", locale);
Date startDate = null;try{    startDate = fromFormat.parse("20170604");}catch(ParseException e){    e.printStackTrace();}return newFormat.format(startDate);

注解的使用(Annotation)

  此帖用来写 本人对注解使用的理解. 并且考虑了下 什么状态下能使用注解.

考虑场景 1: 在你使用注解的地方. 程序调用此地方的方法(或者接口)时 让系统自动调用此方法.

          比如:

ClassA里调用了 注解Anotation时

public class ClassA {

@Anotation(value="kirsong")

public void showA(String name){

System.out.println(name);

}

}

当调用类ClassA的时候 根据方法映射调用 showA方法.

Method methodAnotation=ClassA.class.getDeclaredMethod("showA", new Class[]{String.class});

Anotation an=null;

if(methodAnotation.isAnnotationPrese

//判断该方法是否存在注解

if((an=methodAnotation.getAnnotation(Anotation.class))!=null){

try {

methodAnotation.invoke(mj, an.value());

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

考虑场景2: 根据传送的数据, 分析数据中的注解类并调用他

首先声明注解

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Anotation {

String value() default "val1";

}

创建使用到注解的类

public class ClassA {

@Anotation(value="kirsong")

public void showA(String name){

System.out.println(name);

}

@Anotation

public void showB(String name){

System.out.println(name);

}

public void showC(String name){

System.out.println(name);

}

}

创建根据注解分析器,并调用

public class TargetAnnotation {

public void setPust(Object cls){

try {

Method[] md=cls.getClass().getDeclaredMethods();

Anotation an=null;

for(Method method:md){

if((an=method.getAnnotation(Anotation.class))!=null){

method.invoke(cls, an.value());

}

}

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

}

使用方法

System.out.print("场景3\n");

ClassA ca=new ClassA();

TargetAnnotation target=new TargetAnnotation();

target.setPust(ca);

使用场景3. 使用注解调用接口

定义接口

public interface InterFaceA {

@Anotation(value="intera")

void interA(String value);

}

调用接口中的注解方法

public void setInterfacePust(Object cls){

try {

Class<?>[] interfaces = cls.getClass().getInterfaces(); 

for(Class<?> interClas:interfaces){

Method[] md=interClas.getDeclaredMethods();

Anotation an=null;

cls.getClass().getInterfaces();

for(Method method:md){

if((an=method.getAnnotation(Anotation.class))!=null){

method.invoke(cls, an.value());

}

}

}

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

调用

InterFaceA intera=new InterFaceA(){

@Override

public void interA(String value) {

System.out.print(value);

}

};

target.setInterfacePust(intera);

注解使用 (@interface )

一、什么是注释 

    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源代码的。在J2SE5.0中可以自定义注释。使用时在@后面跟注释的名字。 

有关注解与自定义注解

参考 

http://blog.csdn.net/junshuaizhang/article/details/8526244

http://www.cnblogs.com/peida/archive/2013/04/24/3036689.html

注解的 格式是 @interaface, 并且默认的值是 使用 default. 

首先看看 他是怎么定义的

@Retention(RetentionPolicy.RUNTIME)

public @interface userinfo {

String name() default "";

String age() default "";

}

有个 @Retetion注解来定义范围,如果没有这个 那么在使用它时会报错，更多信息参考 上面的网页

之后再看看 在类中使用 注解的 代码

@userinfo(name="kirsong",age="30")

public class UserCl {

@userinfo(name="kirsongmethod",age="30")

public void outpu(){

}

public static void main(String[] args) {

Class<UserCl> c=UserCl.class;

try {

Method method=c.getMethod("outpu", new Class[]{});

boolean flag=UserCl.class.isAnnotationPresent(userinfo.class);

if(flag){

System.out.println("have annotation");  

}

userinfo ui=(userinfo) method.getAnnotation(userinfo.class);

userinfo uime=(userinfo) c.getAnnotation(userinfo.class);

System.out.println(ui.name());

System.out.println(uime.name());

} catch (NoSuchMethodException | SecurityException e) {

e.printStackTrace();

}

}

}

你会看到 该类中 分别对类声明以及类方法进行了 注解。

之后在main里 分别读取注解的值，如果你想读取 类声明部分的 值的话 就要使用

class.getAnnotation. 如果是 方法的注解值的话就是 method.getAnnotation

string 匹配表达式(matches)

使用 string.matches 判断匹配。

此方法判断 输入的pass字符串 是否是 1-9,a-z,A-Z组成，如果不是范围false

public boolean passInputCheck(String pass){    if (pass.length()<=8)        return false;    else if (!pass.matches("[1-9a-zA-Z]{"+pass.length()+"}"))        return false;    return true;}

下面是描述

字符集:
 []   :方括号表示其中的内容任选其一,代表一个字符
        [1234] 1,2,3,4任选其一
 ()   :表示一组内容,圆括号中可以使用"|"符号

 |   :逻辑或关系
       
 ^   :非,除了
     [^12] 除了1或2的其他字符
    
 -   :范围,范围应从小到大 
     [0-9]表示此字符只能是数字
     [a-f]表示此字符只能是a,b,c,d,e,f之一
     [0-6a-fA-F] 0123456abcdefABCDEF

 {n,m}  :修饰前一个字符,表示其出现n-m次.n应小于m
 {n}   :修饰前一个字符,表示其出现n次
 {n,}  :修饰前一个字符,表示其出现n次以上  
     0[xX][0-9a-fA-F]{1,8}
     0x7fffffff  int最大值

 预定义字符集:
 \d   :表示一个数字.与[0-9]意思一致
 .   :表示任意字符
 \w   :表示单词字符.[0-9a-zA-Z_] 包含个下划线
 \s   :表示空白: \t \n \r \b \p

 \D   :表示非数字
 \W   :非单词字符
 \S   :非空白

 ?   :修饰前一个字符出现0-1次.  {0,1}
 +   :修饰前一个字符出现1次以上.{1,}
 *   :修饰前一个字符出现任意次. {0,}

 注意:"."在正则表达式中代表任意字符,若想表示"."的原意,我们
   需要使用"\."表示
   网页url格式：
 [w]{3}\.[0-9a-zA-Z]+\.com

类方法嵌套使用(如 new AA().a().b())

public class AA{
        public AA a(){return this;}
        public AA b(){return this;}
    }


使用的时候可以直接 AA().a().b();一起定义完.他的返回方法是重点

字符串 进行Unicode转换

有时候 服务器传回来的值是 "\\abcd" 这个值其实就是 "\abcd" 并不能转移
只有当 "\abcd"的时候自动转移, 下边方法解决这一问题而存在的

/** unicode를 한글로 바꾸기 */
    public static String decodeUnicode(final String dataStr) {
        int start = 0;
        int end = 0;
        final StringBuffer buffer = new StringBuffer();
        while (start > -1) {
            end = dataStr.indexOf("\\u", start + 2);
            String charStr = "";
            if (end == -1) {
                charStr = dataStr.substring(start + 2, dataStr.length());
            } else {
                charStr = dataStr.substring(start + 2, end);
            }
            char letter = (char) Integer.parseInt(charStr, 16); // 16进制parse整形字符串。
            buffer.append(new Character(letter).toString());
            start = end;
        }
        return buffer.toString();
    }


下边方法是 我自己升级的 上边方法 如果 "a\\abcd"会出错

public static String decodeUnicode(String dataStr) {
        int end = 0;
        final StringBuffer buffer = new StringBuffer();
        while (true) {
        end=dataStr.indexOf("\\u");
        if(end < 0){
        if (dataStr.length()>0) {
        buffer.append(dataStr);
}
break;
}
        else if (end != 0) {
buffer.append(dataStr.substring(0,end));
dataStr=dataStr.substring(end,dataStr.length());
} else{
           String charStr = "";
           charStr = dataStr.substring(2, 6);
           char letter = (char) Integer.parseInt(charStr, 16);
           buffer.append(new Character(letter).toString());
           dataStr=dataStr.substring(6,dataStr.length());
}
        }
        return buffer.toString();
    }

根据字符串类地址名调用类

Class<?> clss= Class.forName(mXmlFactory.getPACKAGE()+"."+list.get(i).getClassName());
Fragment fragment=(Fragment) clss.newInstance();

Stack(栈)的使用

public static void main(String[] args) { 

        Stack<String> stack = new Stack<String>(); 

        System.out.println("now the stack is " + isEmpty(stack)); 

        stack.push("1"); 

        stack.push("2"); 

        stack.push("3"); 

        stack.push("4"); 

        stack.push("5"); 

        System.out.println("now the stack is " + isEmpty(stack)); 

        System.out.println(stack.peek()); 

        System.out.println(stack.pop()); 

        System.out.println(stack.pop()); 

        System.out.println(stack.search("2"));

        System.out.println(stack.pop());

        System.out.println(stack.pop()); 

        System.out.println(stack.pop());

        System.out.println(stack.pop()); 

       

    } 

    public static String isEmpty(Stack<String> stack) { 

        return stack.empty() ? "empty" : "not empty"; 

    }

now the stack is empty

now the stack is not empty

5

5

4

2

3

2

1

Exception in thread "main" java.util.EmptyStackException

         at java.util.Stack.peek(Unknown Source)

         at java.util.Stack.pop(Unknown Source)

         at com.main.StackClass.main(StackClass.java:22)

泛型的使用

网上关于泛型的有很多.我在这里记录了 我能想到的使用方法。

第一种:泛型类里的T无继承

public class ClassComponenetType<T> {

        

         public String keyname;

        

         /** 判断传的参数是不是String的类 */

         public <T> boolean cls(Class<T> cls){

                  if (cls==String.class) {

                           return true;

                  }

                  return false;

         }

        

         /**

          * 使用泛型类的属性

          * @param t

          */

         public void put(T t){

                  if (t.getClass()==String.class) {

                           keyname=(String) t;

                  }

                 

                  if (t=="你好") {

                           //也会进入到这里

                           keyname=(String) t;

                  }

         }

        

         public String get(){

                  return keyname;

         }

        

         public static void main(String[] args) {

                  ClassComponenetType<String> mCom=new ClassComponenetType<String>();

                  mCom.put("你好");

                  System.out.println("类泛型的使用-->"+mCom.get());

                  System.out.println("泛型变量的使用->"+mCom.cls(String.class));

         }

}

第二种:泛型类里的T有继承

public class ClassComponenetType<T extends GenericClass> {

        

         public String keyname;

         /**

          * 使用泛型类的属性

          * @param t

          */

         public void put(T t){

                  keyname=t.name;

         }

        

         public String get(){

                  return keyname;

         }

        

         public static void main(String[] args) {

                  ClassComponenetType<GenericClass> mCom=new ClassComponenetType<GenericClass>();

                  GenericClass gc=new GenericClass();

                  gc.name="你好";

                  mCom.put(gc);

                  System.out.println("类泛型的使用-->"+mCom.get());

         }

}

public class GenericClass {

public String name;

}