常用对象API、附加:集合补充

基本数据类型对象包装类:

  为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。 用于描述该对象的类就称为基本数据类型对象包装类。

  byte——Byte  short——Short  int——Integer  long——Long  

  float——Float  double——Double  char——Character

  boolean——Boolean

 该包装对象主要用于基本类型和字符串之间的转换。

  基本类型---->字符串

    1、基本类型数值 + “”

    2、用于String类中的静态方法valueOf(基本类型数值);

  字符串---->基本类型

    1、使用包装类中的静态方法  xxxx parseXxx("xxx类型的字符串");

      int parseInt("intString");

      long parseLong("longString");

      注: 只有Character 没有parse方法。

    2、如果字符串被Integer进行对象的封装

      可以使用另一个非静态的方法, intValue();

      将一个Integer 对象转换成基本类型值。

  进制转换 :

    十进制----> 其他进制

      toBinaryString

      toOctalString  toHexString

    其他进制--->十进制

      parseInt( "string" ,radix); // radix----其他进制2,8,16。。。、

集合框架:

    集合类的由来:

      对象用于封装特有数据,对象多了需要存储,如果对象的个数不确定。就编使用集合容器进行存储。

    集合的特点:

      1、用于存储对象的容器; 2、集合的长度是可变的; 3、集合中不可以存储基本数据类型值。

    集合容器因为内部数据结构不同,有多种具体容器。 不断的向上抽取,进形成了集合框架。

  框架的顶层 Collection接口:

   Collection的常见方法: 

  1、添加:

    boolean add(Object obj);

    boolean addAll(Collection coll);

  2、删除

    boolean remove(Object obj);

    boolean removeAll(Collection coll);

    void clear();

  3、判断

    boolean contains(Object obj);

    boolean containsAll(Collection coll);

    boolean isEmpty();   //判断集合中是否有元素

  4、获取

    int size();

    Iterator iterator();   //取出元素的方式 : 迭代器

    该对象必须依赖于具体容器,因为每一个容器的数据结构都不同。

    所以该迭代器对象是在容器中进行内部实现的。

    对于使用容器者而言,具体的实现不重要,只要通过 容器获取到该实现的迭代器的对象即可, 也就是iterator 方法。

    Iterator 接口就是对所有的Collection 容器进行元素取出的公共接口。

  5、其他

    boolean retainAll(Collection coll);  取交集

    Object[]  toArray();  将集合转换成数组

————集合补充部分

  集合框架的工具类。

   Collections :

    public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
      参数:
        list - 要搜索的列表
        key - 要搜索的键
        c - 排序列表的比较器 null 值指示应该使用元素的自然顺序
     List<String> list = new ArrayList<String>();
     list.add("fdssfse");
     list.add("ds");
      替换:  replaceAll(list,"ds", "dfj");
      反转:  reverse(list);

    重要:
       Collections.reverseOrder() : 返回一个反转排序的比较器。
       Collections.shuffle(list); 把集合list 中的元素进行随机的排序。
  

  Arrays:
      用于操作数组的工具类。里面都是静态方法。

    Arrays.asList(数组名) : 将数组变成List集合。
      把数组变成List集合有什么好处?
        ---> 可以使用集合的思想和方法来操作数组中的元素。
      注意: 将数组变成集合,不可以使用集合的增删方法。 因为数组的长度是固定
          可以用 contains get indexOf() subList() .....
         如果增删 会出现UnsupportedOperationException 异常

   如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转换成集合中的元素;
   如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。

    集合名.toArray(指定类型的数组) 集合变数组
       Collection 接口中的toArray 方法
      ArrayList<String> a1 = new ArrayList<String>();
      a1.add("fdsf");
      a1.add("fdsfag");

      String[] arr = a1.toArray(new String[a1.size()]);

      1、指定类型的数组到底要定义多长呢?
        当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size。
        当指定类型的数组长度大于集合的size,就不会新创建数组,而是使用传递进来的数组。
        所以创建一个一个刚刚好的数组最优。
      2、为什么要将集合转换为数组?
          为了限定对元素的操作,不需要进行增删了。

  高级for 循环:
     格式:
     for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)           {

     }

     对集合进行遍历。
       只能获取集合元素,但是不能对集合进行操作。

     迭代器除了遍历,还可以进行remove集合中的元素动作。
     如果是用ListIterator ,还可以在遍历过程中对集合进行增删改查的动作。

   传统for、高级for的区别:
      高级for有一个局限性,必须有被遍历的目标 ; 建议在遍历数组的时候,还是希望是用传统for,因为传统for可以定义脚标。

  可变参数: 格式 :如 int...
    其实就是上一次数组参数的简写形式;
    不用每一次都手动的建立数组对象;
    只要将要操作的元素作为参数传递即可;
    隐式将这些参数封装成了数组。

  方法的可变参数: 在使用的时候注意,一定要定义在可变参数列表的最后面。

  
  静态导入:
    当类名重名时,需要指定具体的包名。
    当方法重名时,需要指定具备所属的对象或者类。
  import static java.util.Arrays.*; 导入的是Arrays这个类中的所有静态成员
  import static java.lang.System.*; 导入了System类中的所有静态成员。


  其他对象 :

  (System): 类中的方法和属性都是静态的

    out :标准输出, 默认是控制台
    in :标准输入, 默认是键盘
    描述系统一些信息;
    获取系统属性信息: Properties getProperties();

   因为properties 是Hashtable的子类, 也就是Map集合一个子类对象。
   那么可以通过map的方法取出该集合中的元素。
   该集合中存储都是字符串,没有泛型定义。

    如何在系统中自定义一些特有的信息呢?
      System.setProperty("mykey","myvalue");

    获取指定属性信息
      String value = System.getProperty("os.name");

    在JVM启动时,动态加载一些属性信息:
      String v = System.getProperty("haha");
      // DOS 命令中 java -Dhaha="fdsfk" 类名
    
    获取所有属性信息:
      for(Object obj : prop.keySet()) {
        String value = (String)prop.get(obj);
        System.out.println(obj+"::"+value);
      }


 (Runtime):
    该类并没有提供构造函数;
    说明不可以new对象,那么会直接想到该类中的方法都是静态的;
    发现该类中还有非静态方法;
    说明该类肯定会提供了方法获取本类对象,而且该方法是静态的,并返回值类型是本类类型。
    
    由这个特点可以看出该类使用了单例设计模式。

    该方式是 static Runtime getRuntime();

  Runtime r = Runtime.getRuntime();
  r.exec("winmine.exe");   //打开路径下的可执行程序

  Process p = r.exec("notepad.exe SystemDemo.java"); //用notepad应用程序打开 后面的文件。
  p.destroy(); // 结束进程


  Date类:

    Date d = new Date();
    Sysem.out.println(d); //打印的时间看不懂,希望有些格式
    
    //将模式封装到SimpleDateFormat对象中
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:ss");

    //调用format方法让模式格式化指定Date对象
    String time = sdf.format(d);

     Calendar类:

                 

    设置时间: set(year,month, days);
    添加或者减去:
      add(int field, int amount) 
         field - 日历字段
         amount - 为字段添加的日期或时间量
          根据日历的规则,为给定的日历字段添加或减去指定的时间量。

  附加小练习: 1、获取任意年的二月有多少天。
          思路:根据指定年设置一个时间就是 c.set(year,2,1);//某年的3月1日;
             c.add(Calenar.DAY_OF_MONTH,-1); //3月1日 往前推一天就是 2月的最后一天。
        2、获取昨天的现在这个时刻。
           c.add(Calenar.DAY_OF_MONTH,-1)
   
   Math—Random :
    
double d = Math.ceil(16.34); //ceil返回大于指定数据的最小整数
     double d1 = Math.floor(12.34); //floor返回小于指定数据的最大整数
      
     long l = Math.round(12.54); //四舍五入

     //output : 17.0  12.0  13

    //产生一个1~10的随机数
    Random r = new Random();
    for(int x=0; x<10; x++) {
      //int d = (int)(Math.Random)*10+1;
      int d = r.nextInt(10)+1;
    }

  附加小练习:1、给定一个小数 ,保留小数后两位

原文地址:https://www.cnblogs.com/jesonjason/p/5108983.html