Java基础【.net对比学习】

基础语法

1）类名：首字母大写，其他拼接字母首字母大写

2）方法名：首字母小写，其他拼接字母首字母大写

3）文件名与类名必须一致

4）包名：所有都小写

5）常量：所有字母大写用下划线_隔开

 

关键词：

       Int32位整型  long 64位整型  程序默认是int 如果使用long 需要在变量后加L或l

Float 单精度小数 double 双精度小数 C#中decimal）默认double使用需要变量后加F或f

Final:修饰常量 运行过程中不会修改其值(c#中const)

       Import：导入类，相当于c#中的using 引用

Package:一系列相关类引入某个包  （C#中某个程序集）问题：这个是指在一些类中package
一个名称那么就是打包进来，一个类只能在一个包中吗？打包后运行生成会生成到不同层级的文件下吗？例如package aaa.bbb.ccc 生成后是在文件 /aaa/bbb/ccc

文件夹创建好后直接新建类，会自动加上package吗

       extends:指继承关系  事列：pulic class Dog extends Anlimal{}

       super：用来访问父类  this：用来访问自己

       implements:  指实现接口  事列：

public interface IWrite{} public class WriteOne implements IWrite {}

instanceof: 测试某个对象是否是某个类的实例化 是否常用？？

Nagtive: 代码用非java方式实现

Synchronized:同一时间只能被一个线程访问  使用场景？？ Synchronize()（C#中lock()）

Volatile:标记可同时多个线程访问，但不能实现同步 不是很理解

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile
对象引用可能是 null。

publicclassMyRunnableimplementsRunnable{privatevolatilebooleanactive;publicvoidrun(){active
=
4000
true; while(active)//第一行{//代码}}publicvoidstop(){active
= false;
// 第二行}}

通常情况下，在一个线程调用 run()方法（在 Runnable开启的线程），在另一个线程调用 stop()方法。如果 第一行 中缓冲区的
active 值被使用，那么在 第二行 的
active 值为false时循环不会停止。

但是以上代码中我们使用了 volatile修饰 active，所以该循环会停止。

volatile可以用在任何变量前面，但不能用于final变量前面，因为final型的变量是禁止修改的。
使用的场景之一，单例模式中采用DCL双锁检测（double checked locking）机制，在多线程访问的情况下，可使用volatitle修改，保证多线程下的可见性。缺点是性能有损失，因此单线程情况下不必用此修饰符。

class
Singleton{
    private
volatile static
Singleton instance =
null;
    private
Singleton()
{
    }
 
    public
static Singleton getInstance(){
        if(instance==null){
            synchronized
(Singleton.class){
                if(instance==null)
                    instance =new
Singleton();
            }
        }
        return instance;
    }
}

 

 

Class:类 一个文件中只能有一个Public 类并且名称与文件名相同，可以包含多个非public类

 

数据类型

       内置数据类型（c#中值类型）八种：byte short int long float doublechar boolean

       引用数据类型

 

 

 

 

 

 

 

 

 

运算符

       ++:写法可以是 i++或++I (c#中只有i++)  i—同理

 

循环

       增强for循环：java5引入 （c#中foreach（）写法的简化）

Test.java 文件代码：

 

Number和Math常用方法

都包含在java.lang 包中

1） XXXValue() 例：i.doubleValue();  int i=5; i.StringValue();

2） compareTo()  例：int i=5  i.compareTo(8);返回-1

参数值必须为number类型

返回值

·       如果指定的数与参数相等返回0。

·       如果指定的数小于参数返回 -1。

·       如果指定的数大于参数返回 1。

 

3） ParseInt() parseDouble()

4） Math.ceil() 向上取整Math.floor()向下取整  返回double类型

5） Math.rint() 四舍五入

6） Math.random() 随机数

  /**
        注意 ==与 equals的区别
        ==它比较的是对象的地址
     equlas比较的是对象的内容
        */

 

 

 

Character ：对 char类型操作的封装类

1） character. toUpperCase(‘c’)字符转大写

2）character.toLowerCase(‘C’) 转小写

 

String

String对象就算concat()也是重新复制一个对象,不适合于字符串的拼接，影响效率；
常用方法：
1）  string.CharAt(index)返回某个下标的字符 string str=”1234”; str.charAt(2);返回3
2）  indexOf()返回某个值第一次出现的下标，indexOf(str,index)返回str从下标index开始出现str的位置；
3）  lastIndexOf()返回字符串最后出现的下标，lastIndexOf (str,index)返回str从下标index开始最后出现str的位置；
4）  matches(正则)返回布尔型
 

StringBulider和StringBuffer：

       StringBulider是非线程安全的（不能同步访问），速度较快

    对字符串进行修改的时候，需要使用 StringBuffer和 StringBuilder类。

和 String类不同的是，StringBuffer和 StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。
 

Arrays类

       来自Java.util.arrays 包

1） Arrays.binarySearch(object[] a,object key) 通过二分法查找a(a必须是排好序的，可调用sort（）)中key对象的下标，如果key在数组中返回下标，从0开始计算；如果key不在数据组中就返回-index  index是指他即将插入的位置，下标从1开始计算

例子：

1.  package Number;  
2. import java.util.Arrays;  
3.  public class IntFunction  
4. {  
5.      public static void main (String []args)  
6.     {  
7.          int a[] = new int[] {1, 3, 4, 6, 8, 9};  
8.         int x1 = Arrays.binarySearch(a, 5);  
9.          int x2 = Arrays.binarySearch(a, 4);  
10.        int x3 = Arrays.binarySearch(a, 0);  
11.         int x4 = Arrays.binarySearch(a, 10);  
12.        System.out.println("x1:" + x1 + ", x2:" + x2);  
13.         System.out.println("x3:" + x3 + ", x4:" + x4);  
14.    }  
15. }  
16./*输出结果： 
17. x1:-4, x2:2 
18.x3:-1, x4:-7 
19. */  

 

 

 

 

 

 

时间日期java.util.Date()

日期比较：

1） 使用getTime()获取毫秒数然后进行比较

2） 使用After()、before()、equals()比较例如：new Date(99,10,12).before(new Date(99,10,18)) 返回 true  因为10.12在10.18之前

3） 使用CompareTo() 返回int类型

 

 

日期格式化：

Java.text.*;包

SimpleDateFormat f=new SimpleDateFormat(“yyyy-MM-dd  hh:m
11570
m:ss”);

f.format(new Date());

 

字符串转日期

SimpleDateFormat f=new SimpleDateFormat(“yyyy-MM-dd”);

Date t=f.parse(“1992-2-3”);

 

 

Java.util.Calendar类

Calendar类对象字段类型

Calendar类中用以下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

 

       Calendarc1=Calendar.getInstance();//默认是当前时间

1） 设置时间c1.Set(2011,10-1,11)；//月份减一

C1.set(calendar.Month,10)

2） 日期增加减少：c1.Add(calendar.Date,10);//日期加十天：c1.Add(calendar.Date,-10);//日期减少十天

3） 日期获取: int m=c1.get(calendar.Month);

 

正则表达式：

1） pattern:使用方式 bool ismatch=Pattern.Matches(“.*uzai.*”,”www.uzai.com”);//返回true 查找www.uzai.com中是否匹配*uzai.*

 

 

数据流

读写文件

如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。

以字符为单位读取文件，常用于读文本，数字等类型的文件
下图是一个描述输入流和输出流的类层次图。

 

1)    FileInputStream:用于读数据流

创建对象：

InputStream st=newFileInputStream(“C://java/hello”);

或者

File f=new File(“C://java/hello”);

InputStream s=new FileInputStream(f);

       例子：

public class ReadFromFile { 

   /**

    * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。

    */ 

   public static void readFileByBytes(String fileName) { 

       File file = new File(fileName); 

       InputStream in = null; 

       try { 

           System.out.println("以字节为单位读取文件内容，一次读一个字节："); 

           // 一次读一个字节 

           in = new FileInputStream(file); 

           int tempbyte; 

           while ((tempbyte = in.read()) != -1) { 

               System.out.write(tempbyte); 

           } 

           in.close(); 

       } catch (IOException e) { 

           e.printStackTrace(); 

           return; 

       }  

       try { 

           System.out.println("以字节为单位读取文件内容，一次读多个字节："); 

           // 一次读多个字节 

           byte[] tempbytes = new byte[100]; 

           int byteread = 0; 

           in = new FileInputStream(fileName); 

           ReadFromFile.showAvailableBytes(in); 

           // 读入多个字节到字节数组中，byteread为一次读入的字节数 

           while ((byteread = in.read(tempbytes)) != -1) { 

                System.out.write(tempbytes, 0,byteread); 

           } 

       } catch (Exception e1) { 

           e1.printStackTrace(); 

       } finally { 

           if (in != null) { 

                try { 

                    in.close(); 

                } catch (IOException e1) { 

                } 

           } 

       } 

   } 

 

   /**

    * 以字符为单位读取文件，常用于读文本，数字等类型的文件

    */ 

   public static void readFileByChars(String fileName) { 

       File file = new File(fileName); 

       Reader reader = null; 

       try { 

           System.out.println("以字符为单位读取文件内容，一次读一个字节："); 

           // 一次读一个字符 

           reader = new InputStreamReader(new FileInputStream(file)); 

           int tempchar; 

           while ((tempchar = reader.read()) != -1) { 

                // 对于windows下，\r\n这两个字符在一起时，表示一个换行。 

                // 但如果这两个字符分开显示时，会换两次行。 

                // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。 

                if (((char) tempchar) != '\r'){ 

                    System.out.print((char)tempchar); 

                } 

           } 

           reader.close(); 

       } catch (Exception e) { 

           e.printStackTrace(); 

       } 

       try { 

           System.out.println("以字符为单位读取文件内容，一次读多个字节："); 

           // 一次读多个字符 

           char[] tempchars = new char[30]; 

           int charread = 0; 

           reader = new InputStreamReader(new FileInputStream(fileName)); 

           // 读入多个字符到字符数组中，charread为一次读取字符数 

           while ((charread = reader.read(tempchars)) != -1) { 

                // 同样屏蔽掉\r不显示 

                if ((charread ==tempchars.length) 

                        &&(tempchars[tempchars.length - 1] != '\r')) { 

                   System.out.print(tempchars); 

                } else { 

                    for (int i = 0; i <charread; i++) { 

                        if (tempchars[i] =='\r') { 

                            continue; 

                        } else { 

                           System.out.print(tempchars[i]); 

                        } 

                    } 

                } 

           } 

 

       } catch (Exception e1) { 

           e1.printStackTrace(); 

       } finally { 

           if (reader != null) { 

                try { 

                    reader.close(); 

                } catch (IOException e1) { 

                } 

           } 

       } 

   } 

 

   /**

    * 以行为单位读取文件，常用于读面向行的格式化文件

    */ 

   public static void readFileByLines(String fileName) { 

       File file = new File(fileName); 

       BufferedReader reader = null; 

       try { 

           System.out.println("以行为单位读取文件内容，一次读一整行："); 

           reader = new BufferedReader(newFileReader(file)); 

           String tempString = null; 

           int line = 1; 

           // 一次读入一行，直到读入null为文件结束 

           while ((tempString = reader.readLine()) != null) { 

                // 显示行号 

                System.out.println("line" + line + ": " + tempString); 

                line++; 

           } 

           reader.close(); 

       } catch (IOException e) { 

           e.printStackTrace(); 

       } finally { 

           if (reader != null) { 

                try { 

                    reader.close(); 

                } catch (IOException e1) { 

                } 

           } 

       } 

   } 

 

   /**

     * 随机读取文件内容

    */ 

   public static void readFileByRandomAccess(String fileName) { 

       RandomAccessFile randomFile = null; 

       try { 

           System.out.println("随机读取一段文件内容："); 

           // 打开一个随机访问文件流，按只读方式 

           randomFile = new RandomAccessFile(fileName, "r"); 

           // 文件长度，字节数 

           long fileLength = randomFile.length(); 

           // 读文件的起始位置 

           int beginIndex = (fileLength > 4) ? 4 : 0; 

           // 将读文件的开始位置移到beginIndex位置。 

           randomFile.seek(beginIndex); 

           byte[] bytes = new byte[10]; 

           int byteread = 0; 

           // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。 

           // 将一次读取的字节数赋给byteread 

           while ((byteread = randomFile.read(bytes)) != -1) { 

                System.out.write(bytes, 0,byteread); 

           } 

       } catch (IOException e) { 

           e.printStackTrace(); 

       } finally { 

           if (randomFile != null) { 

                try { 

                    randomFile.close(); 

                } catch (IOException e1) { 

                } 

           } 

       } 

   } 

 

   /**

    * 显示输入流中还剩的字节数

    */ 

   private static void showAvailableBytes(InputStream in) { 

       try { 

           System.out.println("当前字节输入流中的字节数为:" +in.available()); 

       } catch (IOException e) { 

           e.printStackTrace(); 

       } 

   } 

 

   public static void main(String[] args) { 

       String fileName = "C:/temp/newTemp.txt"; 

       ReadFromFile.readFileByBytes(fileName); 

       ReadFromFile.readFileByChars(fileName); 

       ReadFromFile.readFileByLines(fileName); 

       ReadFromFile.readFileByRandomAccess(fileName); 

   } 

}

 

2)    FileOutPutStream 用于创建文件写入数据流

创建对象：

该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建FileOutputStream对象。
使用字符串类型的文件名来创建一个输出流对象：
OutputStreamf =newFileOutputStream("C:/java/hello")
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
Filef =newFile("C:/java/hello");
OutputStreamf =newFileOutputStream(f);
 

 

 

异常

Java.lang.exception

Java 语言定义了一些异常类在 java.lang标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang包是默认加载到所有的
Java程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

 

如图可以看出所有的异常跟错误都继承与Throwable类，也就是说所有的异常都是一个对象。
从大体来分异常为两块：
1、error---错误：是指程序无法处理的错误，表示应用程序运行时出现的重大错误。例如jvm运行时出现的OutOfMemoryError以及Socket编程时出现的端口占用等程序无法处理的错误。
2、Exception ---异常：异常可分为运行时异常跟编译异常
·       1）运行时异常：即RuntimeException及其之类的异常。这类异常在代码编写的时候不会被编译器所检测出来，是可以不需要被捕获，但是程序员也可以根据需要进行捕获抛出。常见的RUNtimeException有：NullpointException（空指针异常），ClassCastException（类型转换异常），IndexOutOfBoundsException（数组越界异常）等。
·       2）编译异常：RuntimeException以外的异常。这类异常在编译时编译器会提示需要捕获，如果不进行捕获则编译错误。常见编译异常有：IOException（流传输异常），SQLException（数据库操作异常）等。
3、java处理异常的机制：抛出异常以及捕获异常，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。
4、throw跟throws的区别:

public
void test thorws Exception(){
    throw
new Exception();
}

从上面这一段代码可以明显的看出两者的区别。throws表示一个方法声明可能抛出一个异常，throw表示此处抛出一个已定义的异常（可以是自定义需继承Exception，也可以是java自己给出的异常类）。
5、接下来看一下如何捕获异常：
1）首先java对于异常捕获使用的是try---catch或try
--- catch--- finally 代码块，程序会捕获try代码块里面的代码，若捕获到异常则进行catch代码块处理。若有finally则在catch处理后执行finally里面的代码。然而存在这样两个问题：
a.看如下代码：

try{
    //待捕获代码
}catch（Exception e）{
    System.out.println("catchis begin");
    return
1 ；
}finally{
     System.out.println("finallyis begin");
}

在catch里面有一个return，那么finally会不会被执行呢？答案是肯定的，上面代码的执行结果为：

catch
is begin
finally
is begin 

也就是说会先执行catch里面的代码后执行finally里面的代码最后才return1；
b.看如下代码：

try{
   //待捕获代码   
}catch（Exception e）{
    System.out.println("catchis begin");
    return
1 ；
}finally{
     System.out.println("finallyis begin");
     return
2 ;
}

在b代码中输出结果跟a是一样的，然而返回的是return 2；原因很明显，就是执行了finally后已经return了，所以catch里面的return不会被执行到。也就是说finally永远都会在catch的return前被执行。（这个是面试经常问到的问题哦！）
6、对于异常的捕获不应该觉得方便而将几个异常合成一个Exception进行捕获，比如有IO的异常跟SQL的异常，这样完全不同的两个异常应该分开处理！而且在catch里处理异常的时候不要简单的e.printStackTrace()，而是应该进行详细的处理。比如进行console打印详情或者进行日志记录
 

 

集合框架

集合框架体系如图所示

Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中，所以当使用集合框架的时候需要进行导包。

 

Set和List的区别

·       1. Set
接口实例存储的是无序的，不重复的数据。List接口实例存储的是有序的，可以重复的元素。

·       2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

·       3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

 

 

迭代器（Iterator）

 

　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

 

　　Java中的Iterator功能比较简单，并且只能单向移动：

 

　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

 

　　(2) 使用next()获得序列中的下一个元素。

 

　　(3) 使用hasNext()检查序列中是否还有元素。

 

　　(4) 使用remove()将迭代器新返回的元素删除。

 

　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

 

迭代器应用：

 listl = new ArrayList();

 l.add("aa");

 l.add("bb");

 l.add("cc");

 for(Iterator iter = l.iterator(); iter.hasNext();){

 String str = (String)iter.next();

 System.out.println(str);

 }

 /*迭代器用于while循环

 Iterator iter = l.iterator();

 while(iter.hasNext()){

 String str = (String) iter.next();

 System.out.println(str);

 }

 */

遍历Map四种方式