异常处理和常用类

1、异常

异常：就是不正常，是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。 

异常的体系  Throwable

Error

通常指JVM出现重大问题如：运行的类不存在或者内存溢出等。

不需要编写针对代码对其处理，程序无法处理。

Exception 

在运行时运行出现的一些情况，可以通过try,catch,finally处理

异常处理两种方式：

1、捕获异常：try catch 直接处理可能出现的异常！

2、声明异常：throws 声明告诉调用者可能的异常，暴露问题，调用者自己处理！

我的总结：

Exception 和 Error的子类名大都是以父类名作为后缀。

Java异常其实是对不正常情况的一种描述,并将其封装成对象;

Java在 设计异常体系时，将容易出现的异常情况都封装成了对象。

2、异常处理格式

异常处理的5个关键字

try ,catch,

finally 

throw, throws

我的总结：

捕获异常：先捕获小异常再捕获大异常。

程序是调出来的，不是写出来的；多测试是程序员的必修课。

异常处理后，，程序不会因为出现异常而退出!

异常处理格式

try{

//可能出异常的代码

} catch(异常类  对象){

//处理该异常类型的语句

}

[finally] {

//一定会执行的代码

//catch块使用System.exit(1);除外

}

备注：当try语句块出现异常，程序会自动跳到catch语句块去找匹配的异常类型，并执行异常处理语句，finally语句块是异常的统一出口。

3、多异常处理

声明异常时尽可能声明具体异常类型,方便更好的处理;

方法声明几个异常就对应有几个catch块;

若多个catch块中的异常出现继承关系,父类异常catch块放在最后;

在catch语句块使用Exception类作为异常类型时：

所有子类实例都可以使用父类接收(向上转型)，即所有的异常对象都可以使用Exception接收;

注：在java处理多异常时捕获小范围的异常必须放在大范围异常之前。Eg：catch（IoException , Exception）{}

java7 - 同时捕获多个异常类型

Java7之前：

try {
 int a = Integer.parseInt("1");
 int b = Integer.parseInt("0");
 int c = a / b;
 System.out.println(c);
} catch (NumberFormatException e)
{
   e.printStackTrace();
} catch(ArithmeticException e) 
{
 e.printStackTrace();
}

Java7：将多个异常写到了同一个catch代码块

try {
Integer a = Integer.parseInt("1");
Integer b = Integer.parseInt("0");
Integer c = a / b;
System.out.println(c);
} catch (NumberFormatException 
 | ArithmeticException  e ) {
  e.printStackTrace();
}

4、异常的分类

异常分类:

编译时被检查异常;  ---> Checked异常

在程序中必须使用try...catch处理；

编译时不被检测的异常; ---> Runtime异常

可以不使用try...catch处理，但一旦出现异常就将由JVM处理。

异常的分类之Runtime异常

RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题.

说白了,就是程序员造成的,程序员小心谨慎是完全可以避免的异常.比如,事先判断对象是否为null就可以避免NullPointerException异常,事先检查除数不为0就可以避免ArithmeticException异常;

特点:

这种异常Java编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.

异常的分类之Checked异常

除了RuntimeException以及子类,其他的Exception及其子类都是受检查异常,我们也可以称为非RuntimeException异常.

特点:

Java编译器会检查它,也就说程序中一旦出现这类异常,要么是没有try-catch语句捕获,或throws语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.

5、声明异常（throws）

在可能出现异常的方法上声明抛出可能出现异常的类型：

声明的时候尽可能声明具体的异常,方便更好的处理.

当前方法不知道如何处理这种异常，可将该异常交给上一级调用者来处理(非RuntimeException类型的异常)。

方法一旦使用throws声明抛出方法内可能出现的异常类型， 该方法就可以不再过问该异常了；

一个方法调用另一个使用throws声明抛出的方法，自己要么try...catch , 要么也throws;

格式：

public 返回值类型  方法名(参数列表...) 

throws 异常类A,异常类B... {

}

6、throw

自行抛出一个异常对象，抛出异常类的对象；

若throw抛出的是Runtime异常：

程序可以显示使用try...catch来捕获并处理，也可以不管，直接交给方法调用者处理；

若throw抛出Checked异常：

要么放在try里自己处理，要么放在一个throws声明的方法里面，交给调用者处理。

Eg：

public static void main(String[] args) {
  try {
        fn1(1);
  } catch (Exception e) { e.printStackTrace(); }
  fn2(2);
 }
 public static void fn1(int a) throws Exception{
  if(a >0) { throw new Exception("fn1 -- a值不合法"); }
 }
 public static void fn2(int a) {
  if(a >0) { throw new RuntimeException("a值不合法"); }
 }

throws & throw

throws用于在方法上声明该方法不需要处理的异常类型。

throw用于抛出具体异常类的对象。

throws与throw的区别：

thorws用在方法上，后面跟异常类名,可以是多个异常类。

throw用在方法内，后面跟异常对象,只能是一个。

7、finally

异常的统一出口：

不管try块程序是否异常，也不管哪个catch执行，finally块总会执行。

try语句块或会执行的catch语句块使用了JVM系统退出语句例外;//System.exit(1);

try块必须和 catch块或和finally同在，不能单独存在，二者必须出现一个。

不要在finally中使用return 或throw语句，否则将会导致try、catch中的return或throw失效。

我的总结：finally代码块只在一种情况下不执行：System.exit(0)；

Eg：

package reviewDemo;
public class Demo19 {
 public static void main(String[] args) {
  try{
   System.out.println(17/0);
  }catch(Exception e){
   //e.printStackTrace();
   System.out.println("程序错误，请修正！");
  }finally{
   System.out.println("这是finally代码块！");
  }
 }
}

输出：

程序错误，请修正！

这是finally代码块！

8、throw和catch同时使用

当异常出现在当前方法中,程序只对异常进行部分处理,还有一些处理需要在方法的调用者中才能处理完成,此时还应该再次抛出异常,这样就可以让方法的调用者也能捕获到异常;

Eg：

public static void buy(String price) throws Exception {
 try {
  if(price != null)
   Double.parseDouble(price);
 } catch (Exception e) {
  e.printStackTrace();
  throw new Exception("价格不能只能是数字组成");
 }
}
public static void main(String[] args)  {
 try {
  buy(null);
 } catch (Exception e) {
  System.out.println(e.getMessage());
 }
}

9、常用类

String

String表示字符串,所谓字符串,就是一连串的字符;

String是不可变类，一旦String对象被创建，包含在对象中的字符序列(内容)是不可变的，直到对象被销毁；

常量池:JVM中一块独立的区域存放字符串常量和基本类型常量（public static final）。

String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的.

String对象比较:

单独使用""引号创建的字符串都是常量,编译期就已经确定存储到常量池中；

使用new String("")创建的对象会存储到堆内存中,是运行期新创建的；

使用只包含常量的字符串连接符如"aa" + "bb"创建的也是常量,编译期就能确定,已经确定存储到常量池中；

使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在堆中；

Eg：

package string;
public class StringDemo {
 public static void main(String[] args) {
  /*
   *  "" 其实表示的是  String的匿名对象
   */
  String s = "";
  /**
   * String()    初始化一个新创建的 String 对象，使其表示一个空字符序列。
   *  "",不是表示 null
   *  String(String original) 
   *  String s = new String("asd");// s 的值就是 asd
   */
  s = new String();//""
  String s1  = new String("11");
  String s2  = new String("11");
  System.out.println(s1 == s2);//false
  String s3 = "22";
  String s4 = "22";
  System.out.println(s3 == s4);//true
  System.out.println(s3 == s2);//false
  String  s5 = "2" + "2";//这句话其实在编译器编译后的class文件中 已经变成  "22"
  //s5创建了几个对象?//回答：最多一个，如果常量池里面没有就是创建一个，如果常量池里本来就有就是创建零个！下面的str一样的道理。
  String str = "A" +"B"+ "C" +"D" +"E";//String str = "ABCDE";
  System.out.println(s3 == s5);//true
  /**
   * String特点:   不可变的,  一个String对象的内容不能变,一旦内容变量该对象就变成一个新的String对象了
   *  String  str = "AAA";
   *  str = str+"12";
   */
  String str1 = "ABCDE";
  System.out.println(str == str1);//true
  String str2 = "ABC" + "DE";
  System.out.println(str == str2);//true
  String  ss = "AB";
  String str3 = ss + "CDE";//这里的str3在运行期才能确定内容值
  System.out.println(str3 == str2);//false
  String str4 = getStr() +"CDE";//在运行期才能确定 str4的值
  System.out.println(str == str4);//false
  System.out.println(str3 == str4);//false
  /*
   *  String s = "cd"; //一个String对象
   s = s + "itcast"; //itcast也是String对象, 最后的s的值cditcast,也是一个String对象
   System.out.print(s);
   * */
 }
 public static String getStr(){
  return "AB";
 }
}
Eg:
package reviewDemo;
public class Demo20 {
 public static void main(String[] args) {
  //s1,s2只新建了一个对象
  String s1 = "你好";
  String s2 = "你好";
  
  //s3,s4新建了两个对象
  String s3 = "你好";
  String s4 = "你好";
 }
}

10、String方法

String():初始化一个新的 String 对象，使其表示一个空字符序列，并不是返回空(不等于 null)。

String(StringBuffer buffer):根据StringBuffer对象来创建String对象；

String(StringBuilder builder):同上

char charAt(int index):取字符串中指定位置的字符，index从0开始计算。

String concat(String str):连接字符串，等同于 “+”；

boolean contentEquals(StringBuffer buffer):若二者包含的字符序列相同时就返回true;

boolean equals(Object obj):将该字符串与指定对象比较，若二者包含的字符序列相等返回true；

boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写;

byte[] getBytes():将该字符串转换成byte数组；

int indexOf(String str):找出str字符串在该字符串中第一次出现的位置；

int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始;

int lastIndexOf(String str) 返回指定子字符串在此字符串中最后一次出现处的索引;

int length():返回当前字符串长度；

String replace(char oldChar, char newChar) :返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 

String replaceAll(String regex, String replacement) 使用给定的 字符串replacement 替换此字符串所有的regex字符串;

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始.

String[] split(String regex)： 把字符串按指定的字符串分隔开。

String substring(int beginIndex) 返回一个新的字符串，从beginIndex开始截取，它是此字符串的一个子字符串;

String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串;[begin,end)

char[] toCharArray() 将此字符串转换为一个新的字符数组。 

String toLowerCase() 将此 String 中的所有字符都转换为小写;

String toUpperCase()转成大写;

static String valueOf(基本类型 obj):把基本类型值转成字符串;

String trim() ：忽略字符串前导空白和尾部空白。 

String小练习

判断字符串是否由数字组成：

package reviewDemo;
public class Demo20 {
 public static void main(String[] args) {
  String s1 = "123456789";
  String s2 = "12345  6789";
  System.out.print(isnum(s1));
System.out.print(isnum(s2));
 }
 
 public static boolean isnum(String s){
  char []ch = s.toCharArray();
  for (char c : ch) {
   if(!(c > '0' && c <= '9')){
    return false;
   }
  }
  return true;
 }
}

输出：

true

false

判断字符串是否为空：

分析：

字符串的空有两种情况：1、null；2、"";

package reviewDemo;
public class Demo21 {
 public static void main(String[] args) {
  
  String s1 = "";
  System.out.println(isimpty(s1));
  
 }
 
 public static String isimpty(String s){
  if(s != null & !"".equals(s)){
   return "不为空";
  }
  return "为空！";
 }
}

11、StringBuffer 与 StringBuilder

String是不可变类，一旦String对象被创建，包含在对象中的字符序列是不可变的，直到对象被销毁；

StringBuffer 与 StringBuilder对象则是可变的！

举例说明这两个的好处：（不用每次新建对象，效率高！）

package reviewDemo;
public class Demo22 {
 public static void main(String[] args) {
  
  String s = "";
  long begintime = System.currentTimeMillis();
  for(int i = 1;i <= 100000;i++){
   s += i;
  }
  
  
  long endtime = System.currentTimeMillis();
  long time = endtime - begintime;
  System.out.println("运行时间为："+time);
  
  StringBuffer s1 = new StringBuffer();
  s = "";
  begintime = System.currentTimeMillis();
  for(int i = 1;i <= 100000;i++){
   s = ""+i;
   s1 = new StringBuffer(s);
  }
  
  endtime = System.currentTimeMillis();
  time = endtime - begintime;
  System.out.println("运行时间为："+time);
  
 }
}

输出：

运行时间为：82922

运行时间为：15

可以看得出：StringBuffer这两个效率相当高！

StringBuffer：  是线程安全的；

StringBuilder： 是线程不安全的，性能高点，推荐使StringBuilder；(jdk1.5出现)

StringBuffer的字符序列是可变的(通过append等方法操作)

StringBuffer  和  String之间的转换；

String toString() 返回此序列中数据的字符串表示形式。 

StringBuffer(String str):以指定的字符串创建StringBuffer对象。

StringBuffer方法

public StringBuilder()构造一个不带任何字符的StringBuilder对象。 

StringBuffer(String str) ：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

StringBuffer append(Object o) ：将指定的任意类型对象追加到此StringBuffer 对象。 

StringBuffer insert(int offset, Object o) :将任意类型参数的字符串表示形式插入此序列中。 

StringBuffer delete(int start, int end) :移除此序列的子字符串中的字符。 

StringBuffer deleteCharAt(int index): 移除此序列指定位置的 char。  

Eg：

package reviewDemo;
/**
 * 用StringBuilder 或StringBuffer:
 把字符串“ABCDE”;
 转变成字符串“A,B,C,D”
 */
public class Demo23 {
 public static void main(String[] args) {
  //第一种方法：往里面插入；
  StringBuilder sb = new StringBuilder("ABCDE");
  sb.deleteCharAt(sb.length()-1);
  System.out.println(sb);
  for (int i = 0; i < sb.length(); i+=2) {
   sb.insert(i, ",");
  }
  sb.deleteCharAt(0);
  
  System.out.println(sb);
  
  
  //第二种方法：往里面追加，要追加必须遍历，必须换为数组！
  sb = new StringBuilder("ABCDE");
  sb.deleteCharAt(sb.length()-1);
  System.out.println(sb);
  char []cs = sb.toString().toCharArray();
  StringBuilder sb1 = new StringBuilder();
  for (char c : cs) {
   sb1.append(c).append(",");
  }
  sb1.deleteCharAt(sb1.length()-1);
  System.out.println(sb1);
 } 
}

例子：

编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。

package reviewDemo;
/**
 * 编写一个程序，
 * 这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，
 * 例如，根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。
 */
public class Demo24 {
 public static void main(String[] args) {
  int []i = {1,2,3,4,5};
  StringBuilder sb = new StringBuilder();
  for (int j : i) {
   sb.append(j).append(",");
  }
  sb.deleteCharAt(sb.length()-1);
  System.out.println(sb);
 }
}

12、Math和Random和UUID

Math类

public final class Math extends Object

以下X表示double,float,int, long

abs(X x):求绝对值

max(X x1,X x2):求最大值

min(X x1,X x2)：求最小值

public static double random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。和使用new java.util.Random一样

Math.PI;

Random类

负责生成伪随机数；

Random() 创建一个新的随机数生成器。 

int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。 

int nextInt(int n)  返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值n（不包括）之间均匀分布的 int 值。 

package reviewDemo;
public class Demo26 {
 public static void main(String[] args) {
  System.out.println(Math.E);//2.718281828459045
  int a = 12;
  int b = 25;
  
  System.out.println(Math.max(a,b));
  System.out.println(Math.min(a,b));
 }
}
package reviewDemo;
import java.util.UUID;
public class Demo27 {
 public static void main(String[] args) {
  UUID u = UUID.randomUUID();
  String s = u.toString();
  System.out.println(s);//此时是随机生成的，肯定每次都不一样，全网唯一！
  
  u = new UUID(1222222222, 12);//根据构造方法来
  s = u.toString();
  System.out.println(s);//这一个的UUID是固定的。
 }
}

我的总结：UUID（用来标示文件名等（免得文件上传因为名字可能一样而被覆盖），可以保证全网唯一！）

UUID类:用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值。

UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，没有网卡以其他方式获得），UUID的唯一缺陷在于生成的结果串会比较长。

标准的UUID格式为：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx (8-4-4-4-12),其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字;

UUID uuid = UUID.randomUUID();

String uid = uuid.toString();

13、Date和Calendar

处理日期，时间；

大部分的方法已过时，不推荐使用，但是你使用过时的方法也不会报错。

Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

Date(long date)  分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

SimpleDateFormat

java.text.SimpleDateFormat

SimpleDateFormat 是一个与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。 

SimpleDateFormat(String pattern)  用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

public final String format(Date date)将一个 Date 格式化为日期/时间字符串。 

 public Date parse(String source) throws ParseException：把字符串source表示的时间按source的格式转成Date对象。

练习：String与Date的相互转化

按某种时间格式来输出指定的String类型时间

date2String

format

把某种时间格式的String时间转成Date类型时间

string2Date

parse

package reviewDemo;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo28 {
 public static void main(String[] args) throws Exception {
  
  Date d = new Date();
  System.out.println(d);//获取当前时间
  
  //格式化
  SimpleDateFormat  sd = new SimpleDateFormat("yyyy-M-d HH:mm:ss E");
  
  String s = sd.format(d);//这个方法继承于SimpleDateFormat的父类DateFormat类！
  System.out.println(s);
  
  //反格式化
  d = sd.parse(s);
  System.out.println(d);
 }
}

Calendar

推荐使用处理日期和时间的类Calendar;

是抽象类，不能实例化，通过

static Calendar getInstance() 获得一个Calendar对象。

int get(int field):返回指定日历字段值 

静态常量：

YEAR 表示年的字段数字。

MONTH 表示月份字段数字,月份范围是[0,11]。

DATE 表示一个月中的某天。

DAY_OF_MONTH 表示一个月中的某天。

DAY_OF_WEEK 表示一个星期中的某天。

HOUR_OF_DAY / HOUR 表示第几小时

MINUTE  表示第几分钟

SECOND  表示第几秒

Date getTime() 返回一个表示此 Calendar 时间值的 Date 对象。 

void set(int year, int month, int date, int hour, int minute, int second)   设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。

若 amount为负数，则减去一天，

若 amount为正数 ，则加上一天 

例子

package reviewDemo;
import java.util.Calendar;
import java.util.Date;
public class Demo29 {
 public static void main(String[] args) {
  Calendar c = Calendar.getInstance();
  System.out.println(c);
  
  Date d = c.getTime();
  System.out.println(d);
  
  /**
   * void set(int year, int month, int date, int hour, int minute, int second)   
   * 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
   */
  
  c.set(2015, 07, 15, 12, 24, 55);
  d = c.getTime();
  System.out.println(d);
  
  c.add(Calendar.DAY_OF_MONTH, 3);
  d = c.getTime();
  System.out.println(d);
 }
}

我的总结：注意常查看api！

Eg：“查询距今最近三天内的记录”，这里的‘三天内’是什么时间段？

将当前日期时间转换为 只获取当天的00:00:00 

如: 2011-08-08 12:12:12 转化为 2011-08-08 00:00:00、

package reviewDemo;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Demo30 {
 public static void main(String[] args) {
  
  Calendar c = Calendar.getInstance();
  Date d = c.getTime();
  System.out.println(d);
  
  SimpleDateFormat sd = new SimpleDateFormat("yyyy-M-d HH:mm:ss E");
  
  String s = sd.format(d);
  System.out.println(s);
  
  c.set(2015, 8, 23, 13, 24, 15);
  d = c.getTime();
  System.out.println(sd.format(d));
  c.add(Calendar.DAY_OF_MONTH, -3);
  d = c.getTime();
  System.out.println(sd.format(d));
 }
}

输出：

Thu Jul 04 08:56:51 CST 2013

2013-7-4 08:56:51 星期四

2015-9-23 13:24:15 星期三

2015-9-20 13:24:15 星期日

14、System

System 类包含一些与系统相关的类字段和方法。它不能被实例化，类中所有属性和方法都是static,可直接被System调用。

常用方法：

static void exit(int status) 终止虚拟机的运行.对于发生了异常情况而想终止虚拟机的运行,传递一个非0数值,对于正常情况下退出系统传递0值; 

该方法实际调用的是Runtime.getRuntime().exit(int status)；

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组拷贝

static long currentTimeMillis() 返回以毫秒为单位的当前时间。 

String getenv(String name)   获得指定的环境变量;

static void gc()  运行垃圾回收器。

实际上调用了 Runtime中的gc()方法;

Runtime.getRuntime().exec("notepad ");

static Properties getProperties()  取得当前的系统属性。 

static String getProperty(String key) 取得指定键指示的系统属性。 

static String getProperty(String key, String def)  获取用指定键描述的系统属性,def表示默认信息。 

Eg：

package reviewDemo627;
import java.util.Properties;
public class Demo32 {
 public static void main(String[] args) {
  Properties p = System.getProperties();
  System.out.println(p);
  
  System.out.println(System.getenv());
 }
}