精华内容
下载资源
问答
  • 常用工具类的使用

    2021-02-21 14:08:00
    常用工具类的使用 学习内容: // 第1个工具类 Scanner : 用来从终端上获取用户输入的信息 Scanner sc = new Scanner(); String line = sc.nextLine(); // 第2个工具类 Integer: 是int数据的包装类 :用来操作整数...

    学习目标:

    常用工具类的使用

    学习内容:

    // 第1个工具类
    Scanner  : 用来从终端上获取用户输入的信息
    Scanner sc = new Scanner();
    String line = sc.nextLine();
    
    
    // 第2个工具类
    Integer:int数据的包装类 :用来操作整数
    int a = 5;
    Integer aInteger = new Integer(5);
    
    // 将一个阿拉伯字符解析成一个整数
    
    int m = Integer.parseInt("98");
    int max = Integer.MAX;
    
    
    // 第3个工具类
    String: 用来封装一串字符,同时也提供了大量的工具方法
    //String a= new String("xxxxx");
    String a = "xxxx,xx,yyyy";
    
    String[] split = a.split(",");  // 切割字符串  ["xxxx","xx","yyyy"]
    String s = a.subString(0,5); //截取子串   :  xxxx,
    String u = a.toUpperCase();   // 将字符串转成大写  :  XXXX,XX,YYYY
    
    
    // 第4个工具类
    ArrayList<Object>
    
    
    ArrayList<String> sList1;  // 定义一个ArrayList<String>类型的变量sList1,没有赋予任何值,那么这个变量代表的是null
    ArrayList<String> sList2 = new ArrayList<String>();  // 定义一个ArrayList<String>类型的变量sList2,并构造出一个空的list赋值给它
    
    // 添加数据
    sList2.add("小王");
    sList2.add("中王");
    sList2.add("老王");
    
    // 取数据
    String x = sList2.get(2);
    
    
    
    // 第5个工具  HashSet<>
    
    // 集合类型中的工具:迭代器
    HashSet<String> set=new HashSet<>();
    set.add(a);
    set.add(b);
    从set中拿数据
    Iterator it=set.iterator();
    while(it.hasNext()){
    	String ele=it.next();
    	System.out.println(ele);
    }
    
    // 第6个工具  HashMap<>
    HashMap<String,Integer> map=new HashMap<>();
    map.put("a",1);
    map.put("b",2);
    map.put("c",3);
    取数据:
    Integer value=map.get("a");//value:1
    判断是否包含指定的key
    boolean ex=map.containsKey("d");
    删除指定的数据
    map.remove("c");
    遍历整个map的所有数据
    方法1:先获取所有key,然后根据key去map中取value
    Set<String> keySet=map.keySet();
    for(String key:keySet){
    	Integer value=map.get(key);
    	System.out.println(key+","+value);
    }
    方法2:先获取所有Entry<String,Integer>
    Set<Entry<String,Integer>> entrySet=map.entrySet();
    for(Entry<String,Integer> ent:entrySet){
    	system.out.println(ent.getKey()+","+ent.getValue());
    }
    
    // 面向对象编程重要知识:接口
    接口: 用来在模块之间调用时定义功能规范,使得模块之间解耦合,分模块开发变得更加可靠。
    public interface UserService{
    	
    	public User findUserById(String id);
    	
    }
    
    
    实现类:
    public class UserServiceImpl implements UserService{
    	
    	public User findUserById(String id){
    		
    		// 写业务逻辑
    		
    		return u;
    		
    	}
    	
    }
    
    
    
    
    
    
    展开全文
  • 桂 林 理 工 大 学 实 验 报 告 班级 软件工程16-1班 学号...实验名称 包与接口以及常用工具类的使用 日期 2018年06 月28日 一、实验目的: 了解 Java 中包(package)和接口(interface)的作用,掌握包和接口...

     

    一、实验目的:

    了解 Java 中包(package)和接口(interface)的作用,掌握包和接口的设计方法。掌握Math类,String类和StringBuffer类的使用。

    二、实验环境:

    eclipse

    三、实验内容:

    (一)创建并使用自定义包

    1.自定义包的声明方式

           <package>  <自定义包名>

        声明包语句必须添加在源程序的第一行,表示该程序文件声明的全部类都属于这个包。

    2.创建自定义包 Mypackage

    在存放源程序的文件夹中建立一个子文件夹 Mypackage。例如,在“D:\java\javacode”文件夹之中创建一个与包同名的子文件夹 Mypackage(D:\java\javacode\Mypackage),并将编译过的 class 文件放入到该文件夹中。 注意:包名与文件夹名大小写要一致。

    3.在包中创建类

    1)       编写程序KY6_1.java,在源程序中,首先声明使用的包名 Mypackage,然后创建KY6_1类,该类具有计算今年的年份,可以输出一个带有年月日的字符串的功能。

    2)       源代码如下。  

     package Mypackage;                    //声明存放类的包
    
       import java.util.*;                          //引用 java.util 包
    
       public class KY6_1 {   
    
           private int year,month,day;
    
           public static void main(String[] args){}
    
           public KY6_1 (inty,int m,int d) {
    
                year = y;
    
               month = (((m>=1) & (m<=12)) ? m : 1);  
    
               day = (((d>=1) & (d<=31)) ? d : 1);
    
           }     
    
           public static int thisyear() {
    
                return Calendar.getInstance().get(Calendar.YEAR);//返回当年的年份
    
           }
    
           public int year() {
    
               return year;//返回年份
    
           }
    
           public String toString(){
    
                    returnyear+"-"+month+"-"+day;//返回转化为字符串的年-月-日
    
           }
    
          }

    3)       编译KY6_1.java 文件,然后将KY6_1.class 文件存放到 Mypackage 文件夹中(D:\java\javacode\Mypackage)。注意:先不运行程序KY6_1.class!

          4.编写一个需要使用到包 Mypackage 中的KY6_1 类的程序KY6_2.java。

    1)       编写 KY6_2.java 程序:给定某人姓名与出生日期,计算该人年龄,并输出该人姓名,年龄,出生日期。程序使用了KY6_1 的方法来计算年龄。

    2)       源代码如下。 

     import Mypackage.KY6_1; //引用 Mypackage 包中的KY6_1 类
    
      public class KY6_2  
    
      {
    
            private String name;
    
            private KY6_1 birth;
    
                 public static void main(String args[])
    
            {
    
                KY6_2 a = new KY6_2("张驰",1990,1,11);
    
                a.output();
    
            }
    
            public KY6_2 (Stringn1, int y, int m, int d)
    
            {                          //初始化变量与对象
    
                         name = n1;
    
                birth = newKY6_1(y, m, d);
    
            }
    
            public int age()                                   //计算年龄
    
            {
    
                returnbirth.year() - KY6_1.thisyear(); //返回当前年与出生年的差即年龄
    
            }
    
            public void output()
    
            {
    
                System.out.println("姓名 : "+name);
    
               System.out.println("出生日期: "+birth.toString());
    
               System.out.println("今年年龄 : "+age());
    
            }
    
        }

    3)       编译KY6_2.java 程序并运行程序KY6_2.java

    4)       在实验报告中写出该程序的运行结果。

    运行结果:姓名 : 张驰

    出生日期: 1990-1-11

    今年年龄 : -28

    5)       程序运行的结果有没有问题?问题出在哪里?请在实验报告中指出。

    答:运行结果有问题,今年年龄为负数。问题出在:return birth.year() - KY6_1.thisyear(); //返回当前年与出生年的差即年龄 。返回的结果是给定的1990减去当前真实年份,所以结果为负。

    应当改为:return KY6_1.thisyear() - birth.year();

     

    (二)使用接口技术

    定义两个接口,其中各包括一个抽象方法分别用来完成两个数的加法和减法操作,然后创建一个类KY6_3来实现这两个接口中的抽象方法。编写程序KY6_3.java,将源程序写在实验报告中。

    Count.java源代码:

    package 实验六;
    
    interface SumCount{     //定义加法接口
    
                  intsum(int m,int n);                     //定义两个数的加法函数
    
           }
    
    interface MinusCount {         //定义减法接口
    
           intminus(int m,int n);           //定义两个数的减法
    
    }

    KY6_3.java源代码:

    package 实验六;
    
    public class KY6_3 implements SumCount,MinusCount {         //实现接口
    
        public intsum(int m,int n) {       //重写加法函数方法
    
            returnm+n;         //返回两个数的和
    
        }
    
        public intminus(int m, int n) {        //重写减法函数的方法
    
            returnm-n;     //返回两个数的减法
    
        }
    
        publicstatic void main(String[] args) {
    
            KY6_3count=new KY6_3();        //定义一个计算对象
    
            System.out.println(count.sum(15,8));       //调用方法计算两个数的和,并输出
    
            System.out.println(count.minus(19,28));        //调用方法计算两个数的差,并输出
    
        }

    }运行结果:

    23

    -9

    (三)Math类的使用

     1.利用下面的关键代码编写一个完整的程序KY6_4.java,理解Math类的使用。
    System.out.println (Math.abs(-5.8));          //方法abs返回-5.8的绝对值

             System.out.println(Math.ceil (3.2));          //方法ceil返回大于3.2的最小整数,并将该整数转化为double型数据

             System.out.println(Math.floor (3.8));        //方法floor返回小于3.8的最大整数,并将该整数转化为double型数据    

             System.out.println(Math.round (3.8));     //方法round返回3.8的四舍五入的值      

             System.out.println(Math.round (3.2));      //方法round返回3.2的四舍五入的值  

             System.out.println(Math.min (3, 2));        //方法min返回3和2之间最小值  

             System.out.println(Math.max (Math.PI, 4));    //方法max返回π和4之间色最大值   

             System.out.println(Math.log (7.0));        //方法log返回7.0的对数,底数是e

             System.out.println(Math.pow (7,2));        //方法pow返回7的2次方      

             System.out.println(Math.exp (0.4));        //方法exp返回欧拉数 e 的0.4次幂的值      

             System.out.println("e is:"+ Math.E);       //方法 Math.E返回欧拉数e的值 

             System.out.println("π is:"+Math.PI);       //方法Math.PI返回圆周率π的值 

          System.out.println(Math.random());        //返回带正号的 double 型的随机数,该值大于等于 0.0 且小于 1.0
     2.将程序的运行结果写在实验报告中。

    运行结果:

    5.8

    4.0

    3.0

    4

    3

    2

    4.0

    1.9459101490553132

    49.0

    1.4918246976412703

    e is:2.718281828459045

    π is:3.141592653589793

    0.525832983976047

     

    (四)String类与StringBuffer类的使用 1.利用下面的关键代码编写一个完整的程序KY6_5.java,理解String类与StringBuffer类的使用。
           

     package 实验六;
    
    public class KY6_5 {
    
        public static void main(String[]args) {
    
            // TODO Auto-generated methodstub
    
             Strings=new String("This is an demo of the String method.");
    
               System.out.println("Length:"+s.length());      //方法length()返回此字符串的长度
    
               System.out.println("SubString: "+s.substring(11,15));//返回一个新字符串,它是此字符串的一个子字符串,从11的位置到15
    
              StringBuffersf=new StringBuffer("Hello World!");
    
               sf.append(" Hello Java!");          //将指定的字符串追加到此字符序列
    
               sf.insert(12," And");       //将字符串插入此字符序列中,在第12的位置插入And
    
               System.out.println(sf);
    
               System.out.println(sf.charAt(0));  //返回此序列中指定索引处的 char 值H
    
               sf.setCharAt(0,'h');        // 将给定索引处的字符设置为 h
    
               System.out.println(sf.charAt(0));  //返回此序列中指定索引处的 char 值h
    
               System.out.println(sf);
    
        }
    
    }


     2.将程序的运行结果写在实验报告中。

    运行结果:

    Length: 37

    SubString: demo

    Hello World! And Hello Java!

    H

    h

    hello World! And Hello Java!

    四、思考题

    1.    算术运算应该使用什么类?

    答:加、减、乘、除不需要用类。直接用符号就行了。如果是比较大的数进行算术运算,可以使用java.math.BigInteger和java.math.BigDecimal,前者是进行整数的大数操作的,后者是进行小数的大数操作的。详细用法请参考API文档

    2.    Java语言中如何表示字符串?

    答:使用String类或StringBuffer类,结合相应的方法对字符串进行相关的操作。详细用法请参考API文档

    展开全文
  • 第六次实验:包与接口以及常用工具类的使用 一、实验目的 了解 Java 中包(package)和接口(interface)的作用,掌握包和接口的设计方法。掌握Math类,String类和StringBuffer类的使用。 二、实验要求 1. 了解 ...

    第六次实验:包与接口以及常用工具类的使用

     

    一、实验目的

    了解 Java 中包(package)和接口(interface)的作用,掌握包和接口的设计方法。掌握Math类,String类和StringBuffer类的使用。 

    二、实验要求

    1.   了解 Java 系统包的结构,创建并使用自定义包。

    2.   掌握接口的定义与使用。

    3.    掌握Math类的使用。

    4.    掌握String类和StringBuffer类的使用

    三、实验内容

    (一)创建并使用自定义包

    1.自定义包的声明方式

           <package>  <自定义包名>

        声明包语句必须添加在源程序的第一行,表示该程序文件声明的全部类都属于这个包。

    2.创建自定义包 Mypackage

    在存放源程序的文件夹中建立一个子文件夹 Mypackage。例如,在“D:\java\javacode”文件夹之中创建一个与包同名的子文件夹 Mypackage(D:\java\javacode\Mypackage),并将编译过的 class 文件放入到该文件夹中。 注意:包名与文件夹名大小写要一致。

    3.在包中创建类

    1)      编写程序KY6_1.java,在源程序中,首先声明使用的包名 Mypackage,然后创建KY6_1类,该类具有计算今年的年份,可以输出一个带有年月日的字符串的功能。

    2)      源代码如下。

      

     package Mypackage;                    //声明存放类的包
    
       import java.util.*;                          //引用 java.util 包
    
       public class KY6_1 {   
    
           private int year,month,day;
    
           public static void main(String[] args){}
    
           public KY6_1 (inty,int m,int d) {
    
                year = y;
    
               month = (((m>=1) & (m<=12)) ? m : 1);  
    
               day = (((d>=1) & (d<=31)) ? d : 1);
    
           }     
    
           public static int thisyear() {
    
                return Calendar.getInstance().get(Calendar.YEAR);//返回当年的年份
    
           }
    
           public int year() {
    
               return year;//返回年份
    
           }
    
           public String toString(){
    
                    returnyear+"-"+month+"-"+day;//返回转化为字符串的年-月-日
    
           }
    
         }

    3)      编译KY6_1.java 文件,然后将KY6_1.class 文件存放到 Mypackage 文件夹中(D:\java\javacode\Mypackage)。注意:先不运行程序KY6_1.class!

     

         4.编写一个需要使用到包 Mypackage 中的KY6_1 类的程序KY6_2.java。

    1)       编写 KY6_2.java 程序:给定某人姓名与出生日期,计算该人年龄,并输出该人姓名,年龄,出生日期。程序使用了KY6_1 的方法来计算年龄。

    2)       源代码如下。

      import Mypackage.KY6_1; //引用 Mypackage 包中的KY6_1 类
    
      public class KY6_2  
    
      {
    
            private String name;
    
            private KY6_1 birth;
    
                public static voidmain(String args[])
    
            {
    
                KY6_2 a = newKY6_2("张驰",1990,1,11);
    
                a.output();
    
            }
    
            public KY6_2 (Stringn1, int y, int m, int d)
    
            {                          //初始化变量与对象
    
                         name = n1;
    
                birth = newKY6_1(y, m, d);
    
            }
    
            public int age()                                   //计算年龄
    
            {
    
                returnbirth.year() - KY6_1.thisyear(); //返回当前年与出生年的差即年龄
    
            }
    
            public void output()
    
            {
    
               System.out.println("姓名 : "+name);
    
               System.out.println("出生日期: "+birth.toString());
    
                System.out.println("今年年龄 : "+age());
    
            }
    
        }

    3)       编译KY6_2.java 程序并运行程序KY6_2.java

    4)       在实验报告中写出该程序的运行结果。

     

    5)       程序运行的结果有没有问题?问题出在哪里?请在实验报告中指出。

    今年年龄有错

    public int age()                                   //计算年龄
    
           {
    
               return birth.year()-KY6_1.thisyear(); //返回当前年与出生年的差即年龄
    
           }

    Return 内容有错改成  KY6_1.thisyear()-birth.year()  即可

    (二)使用接口技术

    定义两个接口,其中各包括一个抽象方法分别用来完成两个数的加法和减法操作,然后创建一个类KY6_3来实现这两个接口中的抽象方法。编写程序KY6_3.java,将源程序写在实验报告中。

    定义两个接口

    public interface jiekou1 {
    
          abstract int Add(intx,int y);
    
    }
    
     
    
    public interface jiekou2 {
    
        abstract int Sub(int x,inty);
    
    }

    编写add sub方法

    public class jiafa implements jiekou1 {
    
              public int Add(intx,int y){
    
                     return x+y;
    
              }
    
     
    
    public class jianfa implements jiekou2 {
    
        public int Sub(int x,inty){
    
           return x-y;
    
        }
    
    } 

    主方法

    public class KY6_3 {
    
           public static voidmain(String[] args) {
    
                  jianfa      a=newjianfa();
    
                  jiafa b=new jiafa();
    
               System.out.println("接口1运行的结果为"+b.Add(30, 70));
    
               System.out.println("接口2运行的结果为"+a.Sub(50, 30));
    
           }
    
    }

    运行结果

    (三)Math类的使用

     1.利用下面的关键代码编写一个完整的程序KY6_4.java,理解Math类的使用。

       System.out.println(Math.abs(-5.8));
    
           System.out.println(Math.ceil(3.2));
    
           System.out.println(Math.floor(3.8));
    
           System.out.println(Math.round(3.2));
    
           System.out.println(Math.round(3.2));
    
           System.out.println(Math.min(3,2));
    
           System.out.println(Math.max(Math.PI,4));
    
           System.out.println(Math.log(7.0));
    
           System.out.println(Math.pow (7,2));
    
           System.out.println(Math.exp(0.4));
    
           System.out.println("e is:"+ Math.E);
    
           System.out.println("πis:"+Math.PI);
    
           System.out.println(Math.random());

     2.将程序的运行结果写在实验报告中。

    (四)String类与StringBuffer类的使用

     1.利用下面的关键代码编写一个完整的程序KY6_5.java,理解String类与StringBuffer类的使用。

     String s=new String("This is an demo of the String method.");
    
                  System.out.println("Length:"+s.length());
    
                  System.out.println("SubString:"+s.substring(11,15));
    
                  StringBuffer sf=newStringBuffer("Hello World!");
    
                   sf.append(" Hello Java!");
    
                  sf.insert(12," And");
    
                  System.out.println(sf);
    
                  System.out.println(sf.charAt(0));
    
                  sf.setCharAt(0,'h');
    
                  System.out.println(sf.charAt(0));
    
                  System.out.println(sf);
    

     2.将程序的运行结果写在实验报告中。

     

    四、思考题

    1.   算术运算应该使用什么类?

    Math类提供相关的运算方法

    2.   Java语言中如何表示字符串?

    以下3个类型表示字符串

    String s1 = "fdsfd";
    String s2 = new String("fdsdfds");
    String s3 = new String(s2);

    展开全文
  • java常用工具类的使用

    热门讨论 2012-03-19 20:11:37
    类的大部分构造器和方法都已经过时,但是该类使用非常方便,因此目前使用还很普遍,该类的另一个主要功能是,在数据库操作中,它允许将毫秒值表示为SQL DATE值,是数据库操作中java.sql.Date的父类。关于数据库...
  • commons-lang3-3.2.jar中的常用工具类的使用 <dependency> <groupId>commons-lang</groupId> <artifactId>commons-lang</artifactId> </dep...

    commons-lang3-3.2.jar中的常用工具类的使用

     

           <dependency>
                <groupId>commons-lang</groupId>
                <artifactId>commons-lang</artifactId>
           </dependency>

     

     

    1.StringUtils工具类

      可以判断是否是空串,是否为null,默认值设置等操作:

    复制代码
        /**
         * StringUtils
         */
        public static void test1() {
            System.out.println(StringUtils.isBlank("   "));// true----可以验证null, ""," "等
            System.out.println(StringUtils.isBlank("null"));// false
            System.out.println(StringUtils.isAllLowerCase("null"));// t
            System.out.println(StringUtils.isAllUpperCase("XXXXXX"));// t
            System.out.println(StringUtils.isEmpty(" "));// f---为null或者""返回true
            System.out.println(StringUtils.defaultIfEmpty(null, "default"));// 第二个参数是第一个为null或者""的时候的取值
            System.out.println(StringUtils.defaultIfBlank("    ", "default")); 第二个参数是第一个为null或者""或者"   "的时候的取值
        }
    复制代码

    isBlank()  可以验证空格、null、"",如果是好几个空格也返回true

    isEmpty验证不了空格,只有值为null和""返回true 

    两者都验证不了"null"字符串,所以如果验证"null"还需要自己用equals进行验证。

    结果:

    true
    false
    true
    true
    false
    default
    default

     

    简单的贴出几个源码便于记录:

    复制代码
        public static boolean isBlank(final CharSequence cs) {
            int strLen;
            if (cs == null || (strLen = cs.length()) == 0) {
                return true;
            }
            for (int i = 0; i < strLen; i++) {
                if (Character.isWhitespace(cs.charAt(i)) == false) {
                    return false;
                }
            }
            return true;
        }
    
        public static boolean isEmpty(final CharSequence cs) {
            return cs == null || cs.length() == 0;
        }
    复制代码
        public static String defaultIfEmpty(String str, String defaultStr) {
            return StringUtils.isEmpty(str) ? defaultStr : str;
        }

     

      CharSequence是一个接口,String,StringBuffer,StringBuilder等都实现了此接口

    复制代码
    public abstract interface CharSequence {
        public abstract int length();
    
        public abstract char charAt(int paramInt);
    
        public abstract CharSequence subSequence(int paramInt1, int paramInt2);
    
        public abstract String toString();
    }
    复制代码

     

    补充:StringUtils页可以将集合转为String,并且以指定符号链接里面的数据

    复制代码
            List list = new ArrayList(2);
            list.add("张三");
            list.add("李四");
            list.add("王五");
            String list2str = StringUtils.join(list, ",");
            System.out.println(list2str);
    复制代码

    结果:

      张三,李四,王五

     

    补充:有时候我们希望给拼接后的字符串都加上单引号,这个在拼接SQL  in条件的时候非常有用,例如:

            //需求:将逗号里面的内容都加上单引号
            String string = "111,222,333";
            string = "'"+string+"'";//字符串前后加'
            string = StringUtils.join(string.split(","),"','");//先按逗号分隔为数组,然后用','连接数组
            System.out.println(string);

    结果:

    '111','222','333'

     

    补充:null和字符串"null"的区别

    null在JVM中没有分配内存,引用中无任何东西,debug也看不到任何东西,"null"字符串是一个正常的字符串,在JVM分配内存而且可以看到东西

    "null"字符串有东西

     

    null无任何东西:

     

    补充:String.format(format,Object)也可以对字符串进行格式化,例如在数字前面补齐数字

            int num = 50;
            String format = String.format("%0" + 5 + "d", num);
            System.out.println(format);

    结果:

    00050

     

    补充:StringUtils也可以截取字符串,判断是否大小写等操作

    复制代码
            String string = "123_45_43_ss";
            System.out.println(StringUtils.isAllLowerCase(string));// 判断全部小写
            System.out.println(StringUtils.isAllUpperCase(string));// 判断全部大写
            System.out.println(StringUtils.substringAfter(string, "123"));// 截取123之后的
            System.out.println(StringUtils.substringBefore(string, "45"));// 截取45之前的
            System.out.println(StringUtils.substringBefore(string, "_"));// 截取第一个_之前的
            System.out.println(StringUtils.substringBeforeLast(string, "_"));// 截取最后一个_之前的
            System.out.println(StringUtils.substringAfter(string, "_"));// 截取第一个_之后的
            System.out.println(StringUtils.substringAfterLast(string, "_"));// 截取最后一个_之后的
            System.out.println(StringUtils.substringBetween("1234565432123456", "2", "6"));// 截取两个之间的(都找的是第一个)
    复制代码

    结果:

    false
    false
    _45_43_ss
    123_
    123
    123_45_43
    45_43_ss
    ss
    345

     

    补充:StringUtils也可以将字符串分割为数组

    复制代码
    package cn.xm.exam.test;
    
    import org.apache.commons.lang.StringUtils;
    
    public class test {
    
        public static void main(String[] args) {
            String t = "tttt";
            System.out.println(StringUtils.split(t, ","));
        }
    }
    复制代码

    结果:

    [Ljava.lang.String;@5a24389c

    看过深入理解JVM的都知道上面的[代表是一维数组类型,L代表是引用类型,后面的是String类型

     

    补充:  isNoneBlank可以支持多个参数,甚至String数组,用来判断数组里的每一个字符串都是isNotBlank的。

     补充:StringUtils可以获取指定字符出现的次数

    StringUtils.countMatches(str, ":")

     

     补充:StringUtils可以第N次某字符串出现的位置

    StringUtils.ordinalIndexOf(str, ":", 2)

     

    补充:StringUtils可以获取指定字符串之间的字符串,并自动截取为字符串数组

    String[] substringBetweens = StringUtils.substringsBetween(str, ":", ":");

     

    补充:StringUtils可以获取指定字符串之间的字符串(只取满足条件的前两个)

    StringUtils.substringBetween(str2, "/")

     

     

    更全的用法参考:https://blog.csdn.net/anita9999/article/details/82346552

    2.StringEscapeUtils----------转义字符串的工具类

    复制代码
        /**
         * StringEscapeUtils
         */
        public static  void test2(){
            //1.防止sql注入------原理是将'替换为''
            System.out.println(org.apache.commons.lang.StringEscapeUtils.escapeSql("sss"));
            //2.转义/反转义html
            System.out.println( org.apache.commons.lang.StringEscapeUtils.escapeHtml("<a>dddd</a>"));   //&lt;a&gt;dddd&lt;/a&gt;
            System.out.println(org.apache.commons.lang.StringEscapeUtils.unescapeHtml("&lt;a&gt;dddd&lt;/a&gt;"));  //<a>dddd</a>
            //3.转义/反转义JS
            System.out.println(org.apache.commons.lang.StringEscapeUtils.escapeJavaScript("<script>alert('1111')</script>"));   
            //4.把字符串转为unicode编码
            System.out.println(org.apache.commons.lang.StringEscapeUtils.escapeJava("中国"));   
            System.out.println(org.apache.commons.lang.StringEscapeUtils.unescapeJava("\u4E2D\u56FD"));  
            //5.转义JSON
            System.out.println(org.apache.commons.lang3.StringEscapeUtils.escapeJson("{name:'qlq'}"));   
        }
    复制代码

     

    3.NumberUtils--------字符串转数据或者判断字符串是否是数字常用工具类

    复制代码
        /**
         * NumberUtils
         */
        public static  void test3(){
            System.out.println(NumberUtils.isNumber("231232.8"));//true---判断是否是数字
            System.out.println(NumberUtils.isDigits("2312332.5"));//false,判断是否是整数
            System.out.println(NumberUtils.toDouble(null));//如果传的值不正确返回一个默认值,字符串转double,传的不正确会返回默认值
            System.out.println(NumberUtils.createBigDecimal("333333"));//字符串转bigdecimal
        }
    复制代码

    4.BooleanUtils------------判断Boolean类型工具类

    复制代码
        /**
         * BooleanUtils
         */
        public static  void test4(){
            System.out.println(BooleanUtils.isFalse(true));//false
            System.out.println(BooleanUtils.toBoolean("yes"));//true
            System.out.println(BooleanUtils.toBooleanObject(0));//false
            System.out.println(BooleanUtils.toStringYesNo(false));//no
            System.out.println(BooleanUtils.toBooleanObject("ok", "ok", "error", "null"));//true-----第一个参数是需要验证的字符串,第二个是返回true的值,第三个是返回false的值,第四个是返回null的值
        }
    复制代码

     

    5.SystemUtils----获取系统信息(原理都是调用System.getProperty())

    复制代码
        /**
         * SystemUtils
         */
        public static  void test5(){
            System.out.println(SystemUtils.getJavaHome());
            System.out.println(SystemUtils.getJavaIoTmpDir());
            System.out.println(SystemUtils.getUserDir());
            System.out.println(SystemUtils.getUserHome());
            System.out.println(SystemUtils.JAVA_VERSION);
            System.out.println(SystemUtils.OS_NAME);
            System.out.println(SystemUtils.USER_TIMEZONE);
        }
    复制代码

     

    6.DateUtils和DateFormatUtils可以实现字符串转date与date转字符串,date比较先后问题

      DateUtils也可以判断是否是同一天等操作。

    复制代码
    package zd.dms.test;
    
    import java.text.ParseException;
    import java.util.Date;
    
    import org.apache.commons.lang3.time.DateFormatUtils;
    import org.apache.commons.lang3.time.DateUtils;
    
    public class PlainTest {
        public static void main(String[] args) {
            // DateFormatUtils----date转字符串
            Date date = new Date();
            System.out.println(DateFormatUtils.format(date, "yyyy-MM-dd hh:mm:ss"));// 小写的是12小时制
            System.out.println(DateFormatUtils.format(date, "yyyy-MM-dd HH:mm:ss"));// 大写的HH是24小时制
    
            // DateUtils ---加减指定的天数(也可以加减秒、小时等操作)
            Date addDays = DateUtils.addDays(date, 2);
            System.out.println(DateFormatUtils.format(addDays, "yyyy-MM-dd HH:mm:ss"));
            Date addDays2 = DateUtils.addDays(date, -2);
            System.out.println(DateFormatUtils.format(addDays2, "yyyy-MM-dd HH:mm:ss"));
    
            // 原生日期判断日期先后顺序
            System.out.println(addDays2.after(addDays));
            System.out.println(addDays2.before(addDays));
    
            // DateUtils---字符串转date
            String strDate = "2018-11-01 19:23:44";
            try {
                Date parseDateStrictly = DateUtils.parseDateStrictly(strDate, "yyyy-MM-dd HH:mm:ss");
                Date parseDate = DateUtils.parseDate(strDate, "yyyy-MM-dd HH:mm:ss");
                System.out.println(parseDateStrictly);
                System.out.println(parseDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
    复制代码

    结果:

    2018-11-02 07:53:50
    2018-11-02 19:53:50
    2018-11-04 19:53:50
    2018-10-31 19:53:50
    false
    true
    Thu Nov 01 19:23:44 CST 2018
    Thu Nov 01 19:23:44 CST 2018

     

    7.StopWatch提供秒表的计时,暂停等功能

    复制代码
    package cn.xm.exam.test;
    
    import org.apache.commons.lang.time.StopWatch;
    
    public class test implements AInterface, BInterface {
        public static void main(String[] args) {
            StopWatch stopWatch = new StopWatch();
            stopWatch.start();
    
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            stopWatch.stop();
            System.out.println(stopWatch.getStartTime());// 获取开始时间
            System.out.println(stopWatch.getTime());// 获取总的执行时间--单位是毫秒
        }
    }
    复制代码

     结果:

    1541754863180
    5001

     

    8.以Range结尾的类主要提供一些范围的操作,包括判断某些字符,数字等是否在这个范围以内

            IntRange intRange = new IntRange(1, 5);
            System.out.println(intRange.getMaximumInteger());
            System.out.println(intRange.getMinimumInteger());
            System.out.println(intRange.containsInteger(6));
            System.out.println(intRange.containsDouble(3));

    结果:

    5
    1
    false
    true

     

    9.ArrayUtils操作数组,功能强大,可以合并,判断是否包含等操作

    复制代码
    package cn.xm.exam.test;
    
    import org.apache.commons.lang.ArrayUtils;
    
    public class test implements AInterface, BInterface {
        public static void main(String[] args) {
            int array[] = { 1, 5, 5, 7 };
            System.out.println(array);
    
            // 增加元素
            array = ArrayUtils.add(array, 9);
            System.out.println(ArrayUtils.toString(array));
    
            // 删除元素
            array = ArrayUtils.remove(array, 3);
            System.out.println(ArrayUtils.toString(array));
    
            // 反转数组
            ArrayUtils.reverse(array);
            System.out.println(ArrayUtils.toString(array));
    
            // 查询数组索引
            System.out.println(ArrayUtils.indexOf(array, 5));
    
            // 判断数组中是否包含指定值
            System.out.println(ArrayUtils.contains(array, 5));
    
            // 合并数组
            array = ArrayUtils.addAll(array, new int[] { 1, 5, 6 });
            System.out.println(ArrayUtils.toString(array));
        }
    }
    复制代码

    结果:

    [I@3cf5b814
    {1,5,5,7,9}
    {1,5,5,9}
    {9,5,5,1}
    1
    true
    {9,5,5,1,1,5,6}

     

    补充:ArrayUtils可以将包装类型的数组转变为基本类型的数组。

    复制代码
    package cn.xm.exam.test;
    
    import org.apache.commons.lang.ArrayUtils;
    
    public class test {
        public static void main(String[] args) {
            Integer integer[] = new Integer[] { 0, 1, 2 };
            System.out.println(integer.getClass());
    
            int[] primitive = ArrayUtils.toPrimitive(integer);
            System.out.println(primitive.getClass());
        }
    }
    复制代码

    结果:

    class [Ljava.lang.Integer;
    class [I

    看过JVM的知道上面第一个代表是包装类型一维数组,而且是Integer包装类。L代表引用类型,[代表一维。

              第二个代表是基本数据类型int类型的一维数组。

     

    补充:ArrayUtils也可以判断数组是否为null或者数组大小是否为0

    复制代码
        /**
         * <p>Checks if an array of Objects is empty or <code>null</code>.</p>
         *
         * @param array  the array to test
         * @return <code>true</code> if the array is empty or <code>null</code>
         * @since 2.1
         */
        public static boolean isEmpty(Object[] array) {
            return array == null || array.length == 0;
        }
    复制代码

     

    8.  反射工具类的使用

    一个普通的java:

    复制代码
    package cn.xm.exam.test.p1;
    
    public class Person {
        private String name;
    
        public static void staticMet(String t) {
            System.out.println(t);
        }
    
        public Person(String name) {
            this.name = name;
        }
    
        public String call(String string) {
            System.out.println(name);
            System.out.println(string);
            return string;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "test [name=" + name + "]";
        }
    }
    复制代码

     

    反射工具类操作:

    复制代码
    package cn.xm.exam.test;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    import org.apache.commons.lang.reflect.ConstructorUtils;
    import org.apache.commons.lang.reflect.FieldUtils;
    import org.apache.commons.lang.reflect.MethodUtils;
    
    import cn.xm.exam.test.p1.Person;
    
    public class test {
    
        public static void main(String[] args) throws InstantiationException, IllegalAccessException,
                IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
            // ConstructorUtils工具类的使用
            Constructor accessibleConstructor = ConstructorUtils.getAccessibleConstructor(Person.class, String.class);
            Person newInstance = (Person) accessibleConstructor.newInstance("test");
            System.out.println(newInstance.getClass());
            System.out.println(newInstance);
    
            // MethodUtils的使用
            Method accessibleMethod = MethodUtils.getAccessibleMethod(Person.class, "call", String.class);
            Object invoke = accessibleMethod.invoke(newInstance, "参数");
            System.out.println(invoke);
            // 调用静态方法
            MethodUtils.invokeStaticMethod(Person.class, "staticMet", "静态方法");
    
            // FieldUtils 暴力获取私有变量(第三个参数表示是否强制获取)---反射方法修改元素的值
            Field field = FieldUtils.getField(Person.class, "name", true);
            field.setAccessible(true);
            System.out.println(field.getType());
            field.set(newInstance, "修改后的值");
            System.out.println(newInstance.getName());
        }
    }
    复制代码

    结果:

    class cn.xm.exam.test.p1.Person
    test [name=test]
    test
    参数
    参数
    静态方法
    class java.lang.String
    修改后的值

    9.  EqualsBuilder 可以用于拼接多个条件进行equals比较

    例如:

    复制代码
            EqualsBuilder equalsBuilder = new EqualsBuilder();
            Integer integer1 = new Integer(1);
            Integer integer2 = new Integer(1);
    
            String string1 = "111";
            String string2 = "111";
            equalsBuilder.append(integer1, integer2);
            equalsBuilder.append(string1, string2);
            System.out.println(equalsBuilder.isEquals());
    复制代码

     

    结果:

    true

     查看源码:(append的时候判断两个元素是否相等,如果equals已经等于false就直接返回)

    复制代码
        /**
         * <p>Test if two <code>Object</code>s are equal using their
         * <code>equals</code> method.</p>
         *
         * @param lhs  the left hand object
         * @param rhs  the right hand object
         * @return EqualsBuilder - used to chain calls.
         */
        public EqualsBuilder append(Object lhs, Object rhs) {
            if (isEquals == false) {
                return this;
            }
            if (lhs == rhs) {
                return this;
            }
            if (lhs == null || rhs == null) {
                this.setEquals(false);
                return this;
            }
            Class lhsClass = lhs.getClass();
            if (!lhsClass.isArray()) {
                // The simple case, not an array, just test the element
                isEquals = lhs.equals(rhs);
            } else if (lhs.getClass() != rhs.getClass()) {
                // Here when we compare different dimensions, for example: a boolean[][] to a boolean[] 
                this.setEquals(false);
            }
            // 'Switch' on type of array, to dispatch to the correct handler
            // This handles multi dimensional arrays of the same depth
            else if (lhs instanceof long[]) {
                append((long[]) lhs, (long[]) rhs);
            } else if (lhs instanceof int[]) {
                append((int[]) lhs, (int[]) rhs);
            } else if (lhs instanceof short[]) {
                append((short[]) lhs, (short[]) rhs);
            } else if (lhs instanceof char[]) {
                append((char[]) lhs, (char[]) rhs);
            } else if (lhs instanceof byte[]) {
                append((byte[]) lhs, (byte[]) rhs);
            } else if (lhs instanceof double[]) {
                append((double[]) lhs, (double[]) rhs);
            } else if (lhs instanceof float[]) {
                append((float[]) lhs, (float[]) rhs);
            } else if (lhs instanceof boolean[]) {
                append((boolean[]) lhs, (boolean[]) rhs);
            } else {
                // Not an array of primitives
                append((Object[]) lhs, (Object[]) rhs);
            }
            return this;
        }
    复制代码

     

     

    转载自:

    https://www.cnblogs.com/qlqwjy/p/9467178.html

     

    转载于:https://www.cnblogs.com/dw3306/p/11033166.html

    展开全文
  • 常用工具类 StringBuffer、StringBuilder 带有缓冲区字符串对象,可以理解为这个对象拥有自己存储数据空间,在进行赋值时是将数据复制到自己空间中进行操作,所以在方法执行后会修改自己本身数据 ...
  • // 普通Collection创建 List<String> list = Lists.newArrayList(); Set<String> set = Sets.newHashSet(); Map<String, String> map = Maps.newHashMap(); 2.针对Map<String,List<...
  • 1、java对象拷贝 BeanUtils.copyProperties(Object source, Object target) 是属于spring和apache都有提供org.springframework.beans.BeanUtils org.apache.commons.beanutils.BeanUtil PropertyUtils....
  • 掌握Math类,String类和StringBuffer类的使用。 二、实验环境: 一台配置有java环境,装有eclipse的电脑。 三、实验内容:(写出主要的内容)(一) 实验要求1. 了解 Java 系统包的结构,创建并使用自定义包。 2...
  • 掌握Math类,String类和StringBuffer类的使用。 二、实验环境: Windows7平台下的eclipse。 三、实验内容: (一) 创建并使用自定义包源代码如下: package Mypackage; //声明存放类的包 import...
  • 掌握Math类,String类和StringBuffer类的使用。 二、实验要求 1. 了解 Java 系统包的结构,创建并使用自定义包。 2. 掌握接口的定义与使用。3. 掌握Math类的使用。4. 掌握String类和StringBuffer类的使用三...
  • 掌握Math类,String类和StringBuffer类的使用。二、实验环境 Eclipse三、实验内容:(一)创建并使用自定义包1.自定义包的声明方式 &lt;package&gt; &lt;自定义包名&gt; 声明包语句必须添加在源...
  • 掌握Math类,String类和StringBuffer类的使用。二、实验环境:Eclipse三、实验内容:(一)创建并使用自定义包1.自定义包的声明方式 &lt;package&gt; &lt;自定义包名&gt; 声明包语句必须添加在源...
  • Concurrent.Util常用类CyclicBarrier假设有一个场景:每个线程代表一个运动员,当运动员都准备好才一起出发,只要有一个没准备好就大家都等待。public class UseCyclicBarrier { static class Runner implements ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,402
精华内容 2,960
关键字:

常用工具类的使用