JAVA总结，

Java

• Java
  • Java简介
  • Java基础
    • 1 Hello World起步程序
    • 2 Java关键字
    • 3 Java注释
    • 4 Java基本数据类型
    • 5 Java 常量 全局变量 局部变量 类变量静态变量 实例变量
    • 6 Java访问修饰符
    • 7 Java访问运算符
    • 8 Java循环结构
  • Java字符串处理
    • 1获取字符串长度
    • 2获取字符串对应大小写字符串
    • 3获取字符串中指定索引字符字符索引
    • 4比较字符串是否相等是否相同
    • 5字符串进行裁剪连接替换
    • 6对字符串进行前缀以及后缀判断
    • 7对字符串转换数字字节数组字符串数组
  • Java数组
    • 1 一维数组
    • 2 二维数组
  • Java流操作 IO输入输出操作 File文件流操作
    • 1 IO输入输出流
    • 1 File文件输入输出流

1.Java简介

• 创始人: James Gosling 詹姆斯•高斯林
• 创始年份: 1991创建(Oak) 1994改名(Java)
• 曾用名: Oak
• 特性: 跨平台的面向对象高级编程语言
• 运行方式:虚拟机运行编译生成的Java字节码
• 口号: Compile once，run everywhere
• 用途: Web网页应用程序 分布式系统 桌面应用 安卓APP
• 发展: 即将在2017年9月份推出Java 9,现属于Oracle公司知识产权
• IDE集成开发环境: Eclipse JDK配置
• 开源包 框架

2.Java基础

2.1 Hello World起步程序

A.java

public class A {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

使用Eclipse直接运行

输出: Hello World

使用Java命令编译运行

$ javac A.java [生成A.class]

$ java A [运行A.class文件]

输出: Hello World

2.2 Java关键字

关键	描述
abstract	抽象方法，抽象类的修饰符
assert	断言条件是否满足
boolean	布尔数据类型
break	跳出循环或者label代码段
byte 8-bit	有符号数据类型
case switch	语句的一个条件
catch	和try搭配捕捉异常信息
char	16-bit Unicode字符数据类型
class	定义类
const	未使用
continue	不执行循环体剩余部分
default	switch语句中的默认分支
do	循环语句，循环体至少会执行一次
double	64-bit双精度浮点数
else	if条件不成立时执行的分支
enum	枚举类型
extends	表示一个类是另一个类的子类
final	表示一个值在初始化之后就不能再改变了表示方法不能被重写，或者一个类不能有子类
finally	为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
float	32-bit单精度浮点数
for	for循环语句
goto	未使用
if	条件语句
implements	表示一个类实现了接口
import	导入类
instanceof	测试一个对象是否是某个类的实例
int	32位整型数
interface	接口，一种抽象的类型，仅有方法和常量的定义
long	64位整型数
native	表示方法用非java代码实现
new	分配新的类实例
package	一系列相关类组成一个包
private	表示私有字段，或者方法等，只能从类内部访问
protected	表示字段只能通过类或者其子类访问子类或者在同一个包内的其他类
public	表示共有属性或者方法
return	方法返回值
short	16位数字
static	表示在类级别定义，所有实例共享的
strictfp	浮点数比较使用严格的规则
super	表示基类
switch	选择语句
synchronized	表示同一时间只能由一个线程访问的代码块
this	表示调用当前实例或者调用另一个构造函数
throw	抛出异常
throws	定义方法可能抛出的异常
transient	修饰不要序列化的字段
try	表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void	标记方法不返回任何值
volatile	标记字段可能会被多个线程同时访问，而不做同步
while	while循环

2.3 Java注释

public class A{
   /* 这是第一个Java程序
    *它将打印Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String []args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

2.4 Java基本数据类型

• Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

• 1.byte：
  byte 数据类型是8位、有符号的，以二进制补码表示的整数；
  最小值是 -128（-2^7）；
  最大值是 127（2^7-1）；
  默认值是 0；
  byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
  例子：byte a = 100，byte b = -50。

• 2.short：
  short 数据类型是 16 位、有符号的以二进制补码表示的整数
  最小值是 -32768（-2^15）；
  最大值是 32767（2^15 - 1）；
  Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
  默认值是 0；
  例子：short s = 1000，short r = -20000。

• 3.int：
  int 数据类型是32位、有符号的以二进制补码表示的整数；
  最小值是 -2,147,483,648（-2^31）；
  最大值是 2,147,483,647（2^31 - 1）；
  一般地整型变量默认为 int 类型；
  默认值是 0 ；
  例子：int a = 100000, int b = -200000。

• 4.long：
  long 数据类型是 64 位、有符号的以二进制补码表示的整数；
  最小值是 -9,223,372,036,854,775,808（-2^63）；
  最大值是 9,223,372,036,854,775,807（2^63 -1）；
  这种类型主要使用在需要比较大整数的系统上；
  默认值是 0L；
  例子： long a = 100000L，Long b = -200000L。
  “L”理论上不分大小写，但是若写成”l”容易与数字”1”混淆，不容易分辩。所以最好大写。

• 5.float：
  float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  float 在储存大型浮点数组的时候可节省内存空间；
  默认值是 0.0f；
  浮点数不能用来表示精确的值，如货币；
  例子：float f1 = 234.5f。

• 6.double：
  double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
  浮点数的默认类型为double类型；
  double类型同样不能表示精确的值，如货币；
  默认值是 0.0d；
  例子：double d1 = 123.4。

• 7.boolean：
  boolean数据类型表示一位的信息；
  只有两个取值：true 和 false；
  这种类型只作为一种标志来记录 true/false 情况；
  默认值是 false；
  例子：boolean one = true。

• 8.char：
  char类型是一个单一的 16 位 Unicode 字符；
  最小值是 \u0000（即为0）；
  最大值是 \uffff（即为65,535）；
  char 数据类型可以储存任何字符；
  例子：char letter = ‘A’;。

2.5 Java 常量 全局变量 局部变量 类变量<静态变量> 实例变量

• 在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;

• 类变量（静态static变量）：独立于方法之外的属于类的共同的变量，用 static 修饰
• 实例变量: 依据类创建的具体的个人对象都标配的成员变量
• 局部变量: 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
• 全局变量: Java程序中，不能在所有类之外定义全局变量，只能通过在一个类中定义公用、静态的变量来实现一个全局变量

public class A{
    static int allClicks=0;    // 类变量<全局变量>
    A a ; // 实例变量<实例变量>
    String str="hello world";  // 实例变量

    public void method(){
        int i =0;  // 局部变量
    }
}

2.6 Java访问修饰符

• Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
  public 共有的，以 public 修饰符指定，对所有类可见。
  protected 受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。
  default默认的，也称为 default，在同一包内可见，不使用任何修饰符。
  private 私有的，以 private 修饰符指定，在同一类内可见。

2.7 Java访问运算符

• 【<<】左移位运算符 和 【>>】右移位运算符

public class A {

public static void main(String[] args) {
int a =1; //  a<<1 表示  0000 0001 左移1位  ==  0000 0010 【值为 2】
System.out.println("a:"+ (a<<1));

int b =2; //  b<<2 表示  0000 0010 左移1位  ==  0000 1000 【值为 8】
System.out.println("b:"+ (b<<2));

int c =3; //  c<<3 表示  0000 0011 左移3位  ==  0001 1000 【值为 24】
System.out.println("c:"+ (c<<3));

int d =4; //  d>>1 表示  0000 0100 右移1位  ==  0000 0010 【值为 2】
System.out.println("d:"+ (d>>1));

int e =5; //  e>>2 表示  0000 0101 右移2位  ==  0000 0001 【值为 1】
System.out.println("b:"+ (e>>2));

int f =6; //  f>>3 表示  0000 0110 右移3位  ==  0000 0000 【值为 0】
System.out.println("c:"+ (f>>3));

}
}

输出:
a:2
b:8
c:24
d:2
b:1
c:0

• ++自增 和 – 自减运算符
  A++ ：先赋值最后才进行自身+1
  ++A ：先进行自身+1最后才赋值打印
  B- - : 先赋值最后才进行自身-1
  –B : 先进行自身-1最后才赋值

public class B {

public static void main(String[] args) {
int a =10;
System.out.println("a = "+ ++a);

int b =10;
System.out.println("b = "+ b++);

int c =5;
System.out.println("c = "+ --c);

int d =5;
System.out.println("c = "+ d--);
}
}

输出:
a = 11
b = 10
c = 4
c = 5

• instanceof 运算符
  该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

public class B {

public static void main(String[] args) {
    String name = "James";
    boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
    if(name instanceof String){
        System.out.println("name is String type");
    }
    else{
        System.out.println("name is not  String type");
    }
}
}

输出: name is String type

2.8 Java循环结构

---

3.Java字符串处理

3.1获取字符串长度

• 获取字符串中包含的字符数： length()

public class A {
public static void main(String[] args) {
    String str = "abcdef";
    System.out.println(str.length()); //输出字符串长度为5
}
}

• 自动去掉字符串的前空白，尾空白 trim()

public class A {
public static void main(String[] args) {
    String str = " abcdef ";
    System.out.println(str.length());  //输出字符串长度原长度为7
    System.out.println(str.trim().length()); //输出去空白字符串长度为5
}
}

3.2获取字符串对应大小写字符串

public class A {
public static void main(String[] args) {
    String str = "aBcDeF";
    System.out.println(str.toLowerCase()); //输出小写字符串 abcdef
    System.out.println(str.toUpperCase()); //输出大写字符串 ABEDEF
}
}

3.3获取字符串中指定索引字符，字符索引

• 获取指定索引字符charAt(int index)

public class A {
public static void main(String[] args) {
    String str = "aBcDeF";
    System.out.println(str.charAt(0)); //输出字符 a
    System.out.println(str.charAt(1)); //输出字符 B
    System.out.println(str.charAt(2)); //输出字符 c
}
}

• 获取指定字符在此字符串中第一次出现处的索引 indexOf(char c) indexOf(String str)

public class A {
public static void main(String[] args) {
    String str = "aBcDeF";
    System.out.println(str.indexOf('B')); //输出index字符索引 1
    System.out.println(str.indexOf('D')); //输出index字符索引 3
    System.out.println(str.indexOf("eF")); //输出index字符串索引 4
}
}

• 获取指定字符在此字符串中最后一次出现处的索引

public class A {
public static void main(String[] args) {
    String str = "ABCDDCBA";
    System.out.println(str.lastIndexOf('B')); //输出最后index字符'B'的索引 6
    System.out.println(str.lastIndexOf("CBA")); //输出最后index字符“CBA”的索引 5
}
}

3.4比较字符串是否相等是否相同

• ==(是否同一个内存对象) 和 eauql(字符字面量是否相同)
• compareTo(String str) compareToIgnoreCase(String str) 判断字面量

public class A {

    public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";
        String str4 = new String("Strings");

        int result = str1.compareTo( str2 ); 
        System.out.println(result);// 输出为0: 如果参数字符串等于此字符串，则返回值 0

        result = str2.compareTo( str3 );
        System.out.println(result);// 输出为-3 : 如果此字符串小于字符串参数，则返回一个小于 0 的值

        result = str3.compareTo( str1 );
        System.out.println(result);// 输出为3 : 如果此字符串大于字符串参数，则返回一个大于 0 的值

        if(str1.equals(str2)){
            System.out.println("str1 str2 这两个字符串字面相等"); //输出 str1 str2 这两个字符串字面相等
        }
        else {
            System.out.println("str1 str2 这两个字符串字面不相等");    
        }

        if(str1 == str2){
            System.out.println("str1 str2 这两个字符串是同一个对象");//输出str1 str2 这两个字符串是同一个对象
        }
        else {
            System.out.println("str1 str2 这两个字符串不是同一个对象");  
        }

        if(str1.equals(str4)){
            System.out.println("str1 str4 这两个字符串字面相等"); //输出str1 str4 这两个字符串字面相等
        }
        else {
            System.out.println("str1 str4 这两个字符串字面不相等");    
        }

        if(str1 == str4){
            System.out.println("str1 str4 这两个字符串是同一个对象");
        }
        else {
            System.out.println("str1 str4 这两个字符串不是同一个对象");//输出 str1 str4 这两个字符串不是同一个对象
        }

    }

}

3.5字符串进行裁剪，连接，替换

• concat()方法进行字符串的连接
• substring(int index) 进行截取字符串
• replace(char a,char b) replace(str a,str b) 进行字符串替换

public class A {
    public static void main(String args[]) {
        String s = "Hello ";
        System.out.println(s+"World!"); // 输出  Hello World!
        s = s.concat("World!");
        System.out.println(s); // 输出  Hello World!


        System.out.println(s.replace('o', 'X')); // 输出  HellX WXrld!
        System.out.println(s.replace("ll", "LL"));// 输出 HeLLo World!
        System.out.println(s.substring(4));// 输出  o World!
        System.out.println(s.substring(0,4));// 输出  Hell
    }
}

3.6对字符串进行前缀以及后缀判断

• boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
• boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始

public class A {
    public static void main(String args[]) {
        String s = "Hello World";

        System.out.println(s.startsWith("He"));// 输出 true
        System.out.println(s.startsWith("he"));// 输出 false
        System.out.println(s.endsWith("ld")); // 输出 true
        System.out.println(s.endsWith("LD"));// 输出 false

    }
}

3.7对字符串转换，数字，字节数组，字符串数组…

• 全数字型字符串转为数字

public class A {
    public static void main(String args[]) {
        String s = "123456789";

        int value = (int) Integer.valueOf(s);
        System.out.println(value - 9); // 字符串转为int整型再进行加减 输出: 123456780
    }
}

• 字符串转为字节数组，字节数组转为字符串
  byte[] getBytes() byte[] getBytes(String charsetName) 转为字节数组
  static String copyValueOf(char[] data) new String(byte[] arr)字节数组转为字符串

import java.io.UnsupportedEncodingException;

public class A {
    public static void main(String args[]) {
        String s = "ABCDEF";

        try {
            byte[] arr = s.getBytes("UTF-8"); // 字符串转为字节数组
            System.out.println(arr[0]);// 输出第一个字节A对应的ASCII码  65
            System.out.println(arr[1]);// 输出第一个字节A对应的ASCII码  66
            System.out.println(arr[2]);// 输出第一个字节A对应的ASCII码  67
            System.out.println(arr[3]);// 输出第一个字节A对应的ASCII码  68
            System.out.println(arr[4]);// 输出第一个字节A对应的ASCII码  69
            System.out.println(arr[5]);// 输出第一个字节A对应的ASCII码  70

            System.out.println((char) arr[0]);// 输出第一个字节arr[1]对应的ASCII码  65 转为字符为 A
            System.out.println((char) arr[1]);// 输出第一个字节arr[1]对应的ASCII码  66 转为字符为 B
            System.out.println((char) arr[2]);// 输出第一个字节arr[1]对应的ASCII码  67 转为字符为 C
            System.out.println((char) arr[3]);// 输出第一个字节arr[1]对应的ASCII码  68 转为字符为 D
            System.out.println((char) arr[4]);// 输出第一个字节arr[1]对应的ASCII码  69 转为字符为 E
            System.out.println((char) arr[5]);// 输出第一个字节arr[1]对应的ASCII码  70 转为字符为 F
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        byte[] arr2={(byte) 0xFF,(byte)0xAA,(byte)0x7A,(byte)0x6A,(byte)0x55};
        String str2 = new String(arr2);
        System.out.println(str2); // 打印 ��zjU
    }
}

4.Java数组

4.1 一维数组

• 首先必须声明数组变量，才能在程序中使用数组
  dataType[] arrayRefVar ; int[] intArr; String[] strArr;
  int size = 10;
  double[] listDouble = new double[size];
  int[] intArr = new int[size]; //数组初始化方式一
  int[] intArr2 = {4,5,3,2,7,8,90,7,5,325,342} //数组初始化方式二

public class A {
    public static void main(String[] args) {
        double[] myList = { 1.9, 9.9, 3.4, 3.5 }; // 创建方式一: 每一位都赋予初始值

        // 打印所有数组元素
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
        }
        // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is " + total);
        // 查找最大元素
        double max = myList[0];
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max)
                max = myList[i];
        }
        System.out.println("Max is " + max);

        int size = 4;
        int[] myList1 = new int[size]; // 创建方式二: 所有Item默认为0.0
        for (int i = 0; i < myList1.length; i++) {
            myList1[i] = i; // 数组赋值
            System.out.println("value" + i + " " + myList1[i]);
        }
    }
}

4.2 二维数组

• 二维数组 a可以看成有行有列的表
  String s[][] = new String[2][]
  String str[][] ={{“Hello”,”Hello”},{“Today”,”freestyle”}}

import java.util.Arrays;

public class A {
    public static void main(String[] args) {
        String s[][] = new String[2][];//二维数组  其中一维数组长度可以不确定
        s[0] = new String[2];  // 一维数组
        s[1] = new String[3];
        s[0][0] = new String("Good");
        s[0][1] = new String("Luck");
        s[1][0] = new String("to");
        s[1][1] = new String("you");
        s[1][2] = new String("!");
        System.out.println(Arrays.toString(s[0])); //输出 [Good, Luck]
        System.out.println(Arrays.toString(s[1]));//输出 [to, you, !]

        String str[][] ={{"Hello","Hello"},{"Today","freestyle"}};
        System.out.println(Arrays.toString(str[0])); //输出 [Hello, Hello]
        System.out.println(Arrays.toString(str[1]));//输出 [Today, freestyle] 
}
}

5.Java流操作 IO输入输出操作 File文件流操作

5.1 IO输入输出流

• 输入流表示从一个源读取数据，输出流表示向一个目标写数据
  Java 的控制台输入由 System.in 完成
  可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

• 通过new BufferedReader(new InputStreamReader(System.in)).read()读取控制台字符

// 使用 BufferedReader 在控制台读取字符  若输入字符包含q则停止
import java.io.*;

public class A {
  public static void main(String args[]) throws IOException
  {
    char c;
    // 使用 System.in 创建 BufferedReader 
    BufferedReader br = new BufferedReader(new 
                       InputStreamReader(System.in));
    System.out.println("输入字符, 按下 'q' 键退出。");
    // 读取字符
    do {
       c = (char) br.read();
       System.out.println(c);
    } while(c != 'q');
  }
}

• 通过new BufferedReader(new InputStreamReader(System.in)).readLine() 读取控制台字符串字符集

// 使用 BufferedReader.readLine() 在控制台读取字符串  若输入字符串end则停止
import java.io.*;
public class A {
  public static void main(String args[]) throws IOException
  {
    // 使用 System.in 创建 BufferedReader 
    BufferedReader br = new BufferedReader(new
                            InputStreamReader(System.in));
    String str;
    System.out.println("Enter lines of text.");
    System.out.println("Enter 'end' to quit.");
    do {
       str = br.readLine();  //读取字符串
       System.out.println(str);
       System.out.println();
    } while(!str.equals("end"));
  }
}

---

5.1 File文件输入输出流

• FileInputStream 该流用于从文件读取数据，它的对象可以用关键字 new 来创建
  InputStream f = new FileInputStream(“C:/java/hello”);
  File f = new File(“C:/java/hello”);
  InputStream in = new FileInputStream(f);

• FileOutputStream该流用于对文件写数据操作
  它的对象可以用关键字 new 来创建
  OutputStream f = new OutputStream(“C:/java/hello”);
  File f = new File(“C:/java/hello”);
  OutputStream out = new OutputStream(f);

import java.io.*;

public class A{
  public static void main(String args[]){
    try{
      byte bWrite [] = "Hello World".getBytes();
      OutputStream os = new FileOutputStream("/Users/aaa/Desktop/hello.txt");
      for(int x=0; x < bWrite.length ; x++){
      os.write( bWrite[x] ); // 往 文件 /Users/aaa/Desktop/hello.txt 写Hello World字符串
    }
    os.close();

    InputStream is = new FileInputStream("/Users/aaa/Desktop/hello.txt");
    int size = is.available();

    for(int i=0; i< size; i++){
      System.out.print((char)is.read() + "  "); // 从 /Users/aaa/Desktop/hello.txt读取字符
    }
      is.close();
    }catch(IOException e){
      System.out.print("Exception");
    }  
  }
}

• OutputStreamWriter和InputStreamReader是FileOutputStream和FileInputStream的封装

// 使用  OutputStreamWriter(new FileOutputStream(new File("/Users/aaa/Desktop/hello.txt")), "UTF-8")
//append("")方法 来对文件进行写操作

// 使用InputStreamReader(new FileInputStream(new File("/Users/aaa/Desktop/hello.txt")), "UTF-8");
//来对文件进行读取的操作
import java.io.*;

public class A {
    public static void main(String[] args) throws IOException {

        File f = new File("/Users/aaa/Desktop/hello.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建

        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

        writer.append("中文输入");
        // 写入到缓冲区

        writer.append("\r\n");
        // 换行

        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

        fop.close();
        // 关闭输出流,释放系统资源

        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象

        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同

        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流

        fip.close();
        // 关闭输入流,释放系统资源

    }
}

• 文件类File
  File分为文件夹以及文件两类。增删改查等文件操作函数

import java.io.File;
public class A {
   public static void main(String args[]) {
      String dirname = "/Users/aaa/Desktop/";
      File f1 = new File(dirname);
      if (f1.isDirectory()) { // 当前File是否为文件夹
         System.out.println( "Directory of " + dirname);
         String s[] = f1.list(); // 获取当前文件夹的子File
         for (int i=0; i < s.length; i++) {
            File f = new File(dirname + "/" + s[i]);
            if (f.isDirectory()) { // 如果子File 是目录的话 打印目录的名字
               System.out.println(s[i] + " is a directory");
            } else {
               System.out.println(s[i] + " is a file"); // 如果子File 是文件的话 打印文件的名字
            }
         }
      } else {
         System.out.println(dirname + " is not a directory");
    }
  }
}