javase基础知识点

 

 

面向过程 ：面向过程性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源。面向过程没有面向对象易维护、易复用、易扩展。

 

Java性能差的主要原因并不是因为它是面向对象语言，而是Java是半编译语言，最终的执行代码并不是可以直接被CPU执行的二进制机械码

 

什么是字节码?采用字节码的好处是什么?

字节码：.class文件，只面向虚拟机，

Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java程序无须重新编译便可在多种不同操作系统的计算机上运行。

 

JDK：创建和编译程序

jre+编译器javac+工具

JRE：运行时环境

 

字符型常量和字符串常量的区别?

1.形式上：单引号字符和双引号字符

2.含义上：整型值可参与表达式运算；串代表地址值（内存中存放位置）

3.占用内存大小：char占2个字节；串占若干

 

构造器不能被重写，可以重载

 

接口和抽象类的区别是什么？

1.接口默认public，接口不可以有实现；抽象类可以有非抽象方法

2.接口除了static、final变量，不能有其他变量抽象类不一定

3.接口可以多实现；抽象类只能单继承

4.接口是 特殊的抽象类

5.设计层面：接口是对行为的抽象；抽象类是对类的抽象

 

 

 

 

成员变量和局部变量的区别

语法形式/作用域：

成员变量：有static修饰，针对整个类有效；无static修饰，属于实例

局部变量：在方法，语句内有效。

存储位置：

成员变量：随对象创建而存在，随对象消失而消失，存储在堆内存中，有初始值

局部变量：在方法被调用时存在，存储在栈内存中，自动释放，无初始值，需要赋值

 

 == 与 equals(重要)

== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

• 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
• 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

 

 

Persion p = new Persion();在内存中做了哪些事情？

1.将Persion.class文件加入内存中

2.如果p定义在主方法中，那么就会在栈空间开辟一个变量空间p

3.在堆内存给对象分配空间

4.对对象中的成员进行默认初始化

5.对对象中的成员进行显示初始化

6.调用构造代码块对对象进行初始化

7.调用构造方法对对象进行初始化

8.将对象的内存地址赋值给p变量，让p变量指向该对象

 

基本数据类型：

byte：8位，最小数据单位，-128~127

short：16位，

int：32位，-2^31~2^31，和64/32平台无关

long：64位

float：32位，1位符号，8位指数+23位有效尾数

double：64位，最常用，1位符号，11位指数，52位有效尾数，类型范围比long更广，所以不可以直接转换成long

char：16位，

boolean

 

hashCode 与 equals (重要)

为什么重写equals时必须重写hashCode方法？

hashCode（）介绍

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

 

为什么要有 hashCode

我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode： 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

通过我们可以看出：hashCode() 的作用就是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

 

hashCode（）与equals（）的相关规定

1. 如果两个对象相等，则hashcode一定也是相同的
2. 两个对象相等,对两个对象分别调用equals方法都返回true
3. 两个对象有相同的hashcode值，它们也不一定是相等的
4. 因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

 

 

依赖关系有如下三种情况：

1、A类是B类中的（某中方法的）局部变量；

2、A类是B类方法当中的一个参数；

3、A类向B类发送消息，从而影响B类发生变化；

 

组合：

public class Product   {       private Customer customer;       ……   }  

 

关于String的一些比较的原理

String str1 = "str";
String str2 = "ing";		 
String str3 = "str" + "ing";//常量池中的对象		  
String str4 = str1 + str2; //在堆上创建的新的对象	  
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

 

 

 

String s1 = new String("abc");这句话创建了几个对象？

创建了两个对象：

常量池中创建一个对象“abc”，在堆内存中创建一个对象“abc”，是复制过去的。s1的地址指向的是堆内存的地址。

所以==比较并不相等

 

 

Java 中 IO 流分为几种?

• 按照流的流向分，可以分为输入流和输出流；
• 按照操作单元划分，可以划分为字节流和字符流；
• 按照流的角色划分为节点流和处理流。

 

不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好

 

Arrays.asList(myArray) 底层还是数据，并没有实现添加修改

原数组更改那么集合也会随着更改

传递的数组myArray必须是对象数组，而不是基本类型。

 

移位：二进制运算，比普通运算快

左移运算符用“<<”表示，是将运算符左边的对象，向左移动运算符右边指定的位数，并且在低位补零。其实向左移n 位，就相当于乘上2 的n 次方

右移运算符无符号用“>>>”表示，是将运算符左边的对象向右移动运算符右边指定的位数，并且在高位补0，其实右移n 位，就相当于除上2 的n 次方

带符号右移运算符用“>>”表示，是将运算符左边的运算对象，向右移动运算符右边指定的位数。如果是正数，在高位补零，如果是负数，则在高位补1

为什么分基本数据类型和对象（不是一切皆对象吗）
因为基本数据类型的包装类也为对象，基本数据类型存放在栈中，读写速度比堆快
为什么会有包装类呢，因为程序中某些数据可能会返回空值，用包装类其对象可以为null避免了异常，一般建议用包装类，虽然会牺牲一些转换效率，但是可以避免持久化数据时产生的一些异常


instanceof对象是否属于某种类的类型
Animal dog=new Animal();
boolean bool=(dog instanceof String);


构造器：当创建类的对象实例时调用，与类同名，无返回类型，在java中，每个类都必须至少有一个构造器（默认：方法体为空），在创建对象时初始化对象


栈内存：存储基本数据类型、对象引用
堆内存：new出来的数据——堆是栈的一部分，堆是内存快，




求绝对值：return((x>=0)?x:-x);


可以重载构造方法，可以使用者能够零活机动地实例化对象


如果被定义成静态，那么无论有多少个对象，静态成员变量只有一份内存拷贝，即：所有对象共享该成员变量，其作用域只在内部，生命周期贯穿整个程序
实例化对象可调用静态成员变量，类名.也可以，访问的都是同一个，且静态成员变量声明时最好初始化，否则默认值


静态成员方法：只能对静态成员变量进行操作，方法内无this引用




声明对象数组的方式如：Student[] stdAry=new Student[5];
  /*逐一为每个引用创建对象实例*/
  stdAry[0] = new Student("张三", 18);
  stdAry[1] = new Student("李四", 20);
  stdAry[2] = new Student("王五", 24);
  stdAry[3] = new Student("郑六", 21);
  stdAry[4] = new Student("田七", 19);


  for (int i = 0; i < stdAry.length; i++)
  {
    stdAry[i].display();//***************************
  }
}
 

过滤器和拦截器的区别：

　　①拦截器是基于java的反射机制的，而过滤器是基于函数回调。

　　②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。

　　③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

　　④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

　　⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

　　⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

继承：
解决了代码的重用问题。
自动传播代码
减少代码和数据的重复冗余度，并通过增强一致性来减少模块间的接口和界面，从而增强了程序的可维护性
1 父类中的构造方法不能被子类继承，即使它是public的
2 当实例化子类的对象时，必须先执行父类的构造方法，然后再执行子类的构造方法；
3 如果父类的构造方法执行失败，那么子类的对象也将无法实例化。


super：
用途1：在子类的构造方法中，super关键字可以显式地调用父类的构造方法，传递参数，super（实际参数）；且必须为第一条语句
用途2：如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员，super可以明确地指出要访问父类中的成员 super.成员名
public void fun()
  {
    num = 10;        //默认访问自己的成员
    super.num = 20;  //指定访问父类的成员
  }






抽象类：
有抽象方法的类一定是抽象类
public abstract class Shapes{
public abstract void publicraw();
}
抽象类不可以直接实例化，只可以用来继承；
抽象类的派生子类应该提供对其所有抽象方法的具体实现，如果子类如果没有覆盖且实现所有的抽象方法，那子类也必须是一个抽象类只能用于继承；
抽象类可以继承抽象类或非抽象类，单继承
抽象类和抽象方法不能被final修饰
构造方法和静态方法不可以修饰为abstract。
解释：被static修饰的方法在和没有static修饰的方法在内存中的位置不一样，被static修饰的方法属于类，不是给子类继承的
接口：
一个类可以继承一个父类，同时实现多个接口
接口只能用于实现implements
接口中所有方法默认为抽象方法
接口的实现类应实现所有抽象方法，否则将成为抽象类
java只支持单继承，却可以实现多个接口


final：
1、修饰变量：该变量就成为常量，且必须初始化
2、修饰方法：不能被子类重写
3、修饰类：无法被继承


类与类之间的关系：
1、是：继承关系
2、有：指一个类中包含了另一个类的对象，可以理解为类的嵌套


插入排序、冒泡排序——待补充



工具类
每个包装类都有一个静态的valueOf方法，用于将字符串转换成相应包装类的对象
public class LangDemo{
 public static void main(String[] args){
String str="120";
//如果转换失败，引发NumberFormatException异常
Byte objByte=Byte.valueOf(str);
Short objShort=Short.value0f(str);
Integer objInt=Integer.valueOf(str);
Long objLong=Long.valueOf(str);
System.out.println(objByte);
System.out.println(objShort);
System.out.println(objInt);
System.out.println(objLong);
}
}
除了Boolean类和Character类以为，其它的包装类都有静态的parseXxx方法，用于将字符串转换成相对应的原始数据类型值。
public class ParseTest {
  public static void main(String[] args) {
    String str = "116";
    //分别调用各个包装类的paseXxx方法对字符串进行转换，如果转换失败，将报异常
    int i = Integer.parseInt(str);
    short s = Short.parseShort(str);
    byte b = Byte.parseByte(str);
    long l = Long.parseLong(str);
    float f = Float.parseFloat(str);
    double d = Double.parseDouble(str);
    System.out.println(i);
    System.out.println(s);
    System.out.println(b);
    System.out.println(l);
    System.out.println(f);
    System.out.println(d);
  }
}


boolean isLetter(char ch) ——判断字符ch是否为英文字母
boolean isDigit(char ch) ——判断字符ch是否为0-9之间的数字
boolean isUpperCase(char ch) ——判断字符ch是否为大写形式
boolean isLowerCase(char ch) ——判断字符ch是否为小写形式
boolean isWhitespace(char ch) ——判断字符ch是否为英文字母
以上方法为静态方法
public class CharacterDemo {
  public static void main(String[] args) {
    char[] charArray = {'*', '7', 'b', ' ', 'A'};
    for (int i = 0; i < charArray.length; i++) {
      if (Character.isDigit(charArray[i])) {
        System.out.println(charArray[i] + "是一个数字。");
      }
      if (Character.isLetter(charArray[i])) {
        System.out.println(charArray[i] + "是一个字母。");
      }
      if (Character.isWhitespace(charArray[i])) {
        System.out.println(charArray[i] + "是一个空格。");
      }
      if (Character.isLowerCase(charArray[i])) {
        System.out.println(charArray[i] + "是小写形式。");
      }
      if (Character.isUpperCase(charArray[i])) {
        System.out.println(charArray[i] + "是大写形式。");
      }
    }
  }
}






String类
创建一个字符串对象之后，将不能更改
每当更改了字符串，就创建了一个新的字符串对象，原始字符串保持不变


int indexOf(int/String)搜索字符ch在当前字符串中第一次出现的索引，没有出现则返回-1
int lastIndexOf(int/String)搜索字符ch在当前字符串中最后一次出现的索引，没有出现则返回-1


char charAt(int index)用于指定位置提取单个字符，索引值必须为非负，返回类型为char，起始位置为0
String substring(int index)用于提取冲index指定的位置开始的字符串部分，起始位置为0
String substring（int begin，int end）用于提取始末之间的字符串，包含begin,不包含end
如果 start 与 end 相等，那么该方法返回的就是一个空串（即长度为 0 的字符串）。
如果 start 比 end 大，那么该方法在提取子串之前会先交换这两个参数。如果 start 或 end 为负数，那么它将被替换为 0。


String replace(char oldChar, char newChar)用于将调用字符串中出现oldChar指定的字符全部都替换为newChar指定的字符


String toUpperCase()返回当前字符串的全大写形式
String toLowerCase()返回当前字符串的全小写形式


StringBuffer类的常用方法
StringBuffer insert(int dex,x x)将x插入到索引为index的位置，x可以为任何类型的数据
int length()获得当前长度
void setCharAt(int index,char ch)使用 ch 指定的新值替换 index指定的位置上的字符
String toString()转换为字符串形式
StringBuffer reverse() 将当前StringBuffer对象中的字符序列倒置
StringBuffer delete(int start,int end)删除当前对象中从start位置开始直到 end 指定的索引 位置的字符序列
StringBuffer deleteCharAt(int index)将删除 index 指定的索引处的字符
StringBuffer replace(int start, int end, String str)此方法使用一组字符替换另一组字符。将用替换字符串从 start指定的位置开始替换，直到 end 指定的位置结束
append(String str) 末尾连接
public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer strBuf = new StringBuffer("Java");
    
        strBuf.append(" Guide Ver1/");  //连接
        System.out.println(strBuf);
        strBuf.append(3);
        System.out.println(strBuf);


        strBuf.insert(5, "Student");    //插入
        System.out.println(strBuf);
    
        strBuf.setCharAt(20, '.');      //替换字符
        System.out.println(strBuf);
    
        strBuf.reverse();               //倒序
        System.out.println(strBuf);
    
        String str = strBuf.toString();
        System.out.println(str);
    }


JDK1.5以后，提供了一个新的字符缓冲区：StringBuilfer——非线程安全；提供了自动封解箱机制（包装类）


Math类
该类构造方法被修饰为private，所以不能被实例化
所有方法均为静态
该类被修饰为final，因此无子类


常用方法：
static int abs(int a)求a的绝对值
static double pow(double a,double b)求a的b次方幂
static double sqrt(double a)求a的平方根
static round(float a)a的四舍五入
static double ceil(double a) 向上取整
static double floor(double a)向下取整




Object类
Object类就是单根体系的根，即所有类的共同父类

该类里面所用到的方法

private static native void registerNatives();
/*对象初始化时自动调用此方法*/
static {
    registerNatives();
}
/*返回此Object的运行时类*/
public final native Class<?> getClass();
/*
hashCode的常规协定是：
1.在java应用程序执行期间,在对同一对象多次调用hashCode()方法时,必须一致地返回相同的整数,前提是将对象进行equals比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。
2.如果根据equals(object)方法,两个对象是相等的,那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的整数结果。
3.如果根据equals(java.lang.Object)方法,两个对象不相等,那么对这两个对象中的任一对象上调用hashCode()方法不要求一定生成不同的整数结果。但是,程序员应该意识到,为不相等的对象生成不同整数结果可以提高哈希表的性能。
*/
public native int hashCode();
/*比较对象的内存地址,跟String.equals方法不同,它比较的只是对象的值*/
public boolean equals(Object obj) {
    return (this == obj);
}
/*本地clone方法,用于对象的复制*/
protected native Object clone() throws CloneNotSupportedException;
/*
返回该对象的字符串表示,非常重要的方法
getClass().getName();获取字节码文件的对应全路径名例如java.lang.Object
Integer.toHexString(hashCode());将哈希值转成16进制数格式的字符串。
*/
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
/*唤醒在此对象监视器上等待的单个线程*/
public final native void notify();
/*唤醒在此对象监视器上等待的所有线程*/
public final native void notifyAll();
/*
在其他线程调用此对象的notify()方法或notifyAll()方法前,导致当前线程等待。换句话说,此方法的行为就好像它仅执行wait(0)调用一样。
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待,直到其他线程通过调用notify方法或notifyAll方法通知在此对象的监视器上等待的线程醒来,然后该线程将等到重新获得对监视器的所有权后才能继续执行。
*/
public final native void wait(long timeout) throws InterruptedException;
/*在其他线程调用此对象的notify()方法或notifyAll()方法,或者超过指定的时间量前,导致当前线程等待*/
public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0) {
        timeout++;
    }

    wait(timeout);
}

public final void wait() throws InterruptedException {
    wait(0);
}


/*当垃圾回收期确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。*/
protected void finalize() throws Throwable { }

java.lang包是Java中最基础的一个包，也是唯一一个无需显示声明就默认导入包；


String明明可以执行串联操作，为什么说是静态的不可改变的呢？
String的确可以执行串联操作，String s1=”abc”;String s2=”123”;s1=s1+s2;代码运行后s1的确也变成了”abc123”,然而改变的却不是原始的字符串对象，JAVA会新建一个字符串，把结果放到新建的字符串对象中，并将新字符串的引用传递给s1,因此，现在的s1跟以前的”abc”字符串已经不存在任何关系了。




Date类
Date类的常用方法：
boolean after(Date when)如果当前日期对象在when指定的日期对象之后，返回true，否则返回false
boolean before(Date when)如果当前日期对象在when指定的日期对象之前，返回true，否则返回false
void setTime(long time)设置日期对象，以表示自1970年1月1日起的指定毫秒数
boolean equals(Object obj)如果两个日期对象完全相同，返回true，否则返回false
String toString()返回日期的格式化字符串，包括星期几
public class DateDemo
{
  public static void main(String[] args)
  {
    Date date = new Date();  //获得当前的系统日期和时间
    System.out.println("今天的日期是：" + date);


    long time = date.getTime();  //获得毫秒数
    System.out.println("自1970年1月1日起以毫秒为单位的时间(GMT):" + time);


    //截取字符串中表示时间的部分
    String strDate = date.toString();
    String strTime = strDate.substring(11, (strDate.length() - 4));
    System.out.println(strTime);
    strTime = strTime.substring(0, 8);
    System.out.println(strTime);
  }
}


Calendar类也是用来操作日期和时间的类，但它可以以整数形式检索类似于年、月、日之类的信息；
Calendar类是抽象类，无法实例化，要得到该类对象只能通过调用getInstance方法来获得；
Calendar对象提供为特定语言或日历样式实现日期格式化所需的所有时间字段。
public class CalendarDemo
{
  public static void main(String[] args)
  {
    //创建包含有当前系统时间的Calendar对象
    Calendar cal = Calendar.getInstance();    
    //打印Calendar对象的各个组成部分的值
    System.out.print("当前系统时间：");
    System.out.print(cal.get(Calendar.YEAR) + "年");
    System.out.print((cal.get(Calendar.MONTH) + 1) + "月");
    System.out.print(cal.get(Calendar.DATE) + "日 ");
    System.out.print(cal.get(Calendar.HOUR) + ":");
    System.out.print(cal.get(Calendar.MINUTE) + ":");
    System.out.println(cal.get(Calendar.SECOND));
    //将当前时间添加30分钟，然后显示日期和时间
    cal.add(Calendar.MINUTE, 30);
    //返回与调用对象具有相同时间的Date对象
    Date date = cal.getTime();
    System.out.println("将当前时间添加30分钟后的时间：" + date);
  }
}
日期格式化
Date nowTime=new Date(); 
System.out.println(nowTime); 
SimpleDateFormat time=new SimpleDateFormat("yyyy MM dd HH mm ss"); 
System.out.println(time.format(nowTime)); 




Random类
专门用来生成随机数
常用方法：
int nextInt()从随机数生成器返回下一个整型值






集合
集（Set）不允许重复
列表（List）区别顺序
映射（Map)键值对
Java集合中只能保存引用类型的数据，实际上存放的是对象的引用，而非对象本身
Collection接口:
Set/List
boolean add(Object o)
boolean remove(Object o)
int size()
Object get(int index)返回指定索引位置的元素
boolean isEmpety();
boolean contains(Object o)
int indexOf(Object element)判断element在ArrayList对象中是否存在，存在返回对应的索引，否则返回-1
Object[] toArray()将当前集合中所有元素转换成一维数组
void clear() 删除集合对象中的所有元素
void removeAll(Collection c) 从集合中删除集合c中的所有元素


ArrayList类：
ArrayList是长度可变的对象引用数组，称为动态数组；
随着元素的添加，元素数目的增大，数组容量也会随之自动扩展；
访问和遍历数组元素时，ArrayList的性能优越；


LinkedList类
与ArrayList相比，如果需要频繁地添加和删除元素，LinkedList的性能更加优越；
LinkedList类继承了AbstractSequentialList类，并实现了List接口；
Vector类：线程同步


HashMap类：
HashMap以键值对的形式存储元素；
对于HashMap来说，不存在索引，也就是说不可以通过索引来访问元素，只能通过键去访问值，如要快速检索元素的话，HashMap性能优越；
由于没有索引，所以HashMap中元素的存放是没有顺序的；
HashMap类继承了AbstractMap类，并实现了Map接口。
区别：
Hashtable:同步的，线程安全的，键值不允许为null
HashMap：非线程同步；允许键值为null


ArrayList类继承了AbstractList类并实现了List接口。




数组
数组是一个变量，存储相同数据类型的一组数据
如何使用数组：
1、声明数组：int[] a或int a[];
2、分配空间：a=new int[5];
3、赋值：a[0]=8;
4、处理数据：a[0]=a[0]*10;
边声明边赋值：
1、int[] b={100,30,……｝;
2、int[] b=new int[]{32,34,56};
动态从键盘录入信息并赋值
Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     score[i] = input.nextInt();
}
利用数组求平均值：
int [ ] score = {60, 80, 90, 70, 85};
int sum = 0;
double avg;
for(int index = 0; index < score.length; index++){
     sum = sum + score[index];
}
avg = sum / score.length; 
创建数组并赋值的方式必须在一条语句中完成
int[ ] score = new int[5];
score2 = {60, 80, 90, 70, 85}; 
编译出错


求最大值：
       //计算成绩最大值
        max = score[0];
        for (int index = 1;index < 5;index++) {
              if (score[index] > max) {
                      max = score[index];
              }
        }
        System.out.println("本次考试的五位学生的最高分是： " + max);


排序：
       import java.util.*;   //导入包
       ……
       int[ ] score = new int[5];
       Scanner input = new Scanner(System.in); 
       System.out.println("请输入5位学员的成绩：");
       for(int i = 0; i < 5; i++){
score[i] = input.nextInt();  //依次录入5位学员的成绩
        }
       Arrays.sort(score);    //排序-对数组进行升序排列
       for(int index = 0; index < score.length; index++){
              System.out.println(score[index]);   //输出结果
        }


有一列乱序的字符，‘a’,‘c’,‘u’,‘b’,‘e’,‘p’,‘f’,‘z’，排序并按照英文字母表的逆序输出
char list[ ] = {'a','c','u','b','e','p','f','z'};
Arrays.sort(list);
for (int i = list.length - 1; i >= 0; i-- ) {
      System.out.println(list[i]);
}




字符串
equalsIgnoreCase比较时忽略大小写
concat（）字符串连接
String s = new String("你好，");
String name = new String("张三！");
String sentence = s.concat(name);
System.out.println(sentence);
输出结果：你好，张三！


Queue
  队列，jdk1.5版本新增接口，Queue实现了“先进先出”（FIFO）的存储结构。Queue是Collection的子接口，具有所有集合基本操作，除此之外，Queue还提供了一些新的插入、提取、查询等方法。


LindedList
链表，其不仅实现了List接口，还实现了Queue接口，可以说链表同时也可以作为一个队列对象使用，使用方法与ArrayLisproperties文件中写值




Properties类
Properties类是Hashtable类的子类，所以也间接地实现了Map接口。在实际应用中，常使用Properties类对属性文件进行处理
常用方法：load（）；加载文件；
getProperty（key）通过key值获得对应的value值
setProperty（String key，String value）给properties文件中写值。


Collections排序方法
public class GenericsList {
public static void main(String[] args) {
User user4= new User(11); // 创建用户对象
User user1 = new User(14);
User user2 = new User(13);
User user3 = new User(9);
List<User> userList = new ArrayList<User>(); // 创建集合对象，存放用户对象
userList.add(user4);
userList.add(user1);
userList.add(user2);
userList.add(user3);
for(User u:userList){
System.out.println(u.getUserAge());
}
Collections.sort(userList);//调用排序方法
 for(User u:userList){
System.out.println(u.getUserAge());
}
}




IO流
File类
//在当前目录下创建一个与aaa.txt文件名相关联的文件对象
File f1 = new File("aaa.txt");
//指明详细的路径以及文件名，请注意双斜线或用反斜杠
File f2 = new File("D:\\Java\\Hello.java");
//指明详细的路径以及目录名，请注意双斜线
File f3 = new File("D:\\Java");


File类的常用方法
boolean exists()判断文件是否存在
boolean is File()判断是否为文件
boolean isDirectory()判断是否为目录
String getName()获得文件的名称
String getAbsolutePath()获得文件的绝对路径
long length()获得文件的长度
boolean createNewFile() throws IOException创建文件，有可能抛除IOException异常，必须捕捉
boolean delete()删除文件


File类的遍历
String[] list()将目录下的子目录及文件的名字，返回到String数组中
File[] listFiles()将目录下的子目录及文件的实例返回到File数组中


字节流与字符流
InputStream和OutputStream的子类都是字节流
节点流中常用类
   -字节输入流 FileInputStream
  -字节输出流 FileOutputStream
  -字符输入流 FileReader
  -字符输出流 FileWriter


处理流中常用类
  -缓冲字节输出流 BufferedOutputStream
  -缓冲字节输入流 BufferedInputStream
  -缓冲字符输入流 BufferedReader
  -缓冲字符输出流 BufferedWriter
字符缓冲输出流，把写入的数据先写入到内存，再使用flush()方法将内存数据刷到硬盘上。在使用字符缓冲输出流时，一定先flush(),然后再close(),避免数据的丢失。


基本数据类型和引用数据类型作为参数时的区别
如果参数是基本数据类型，传递的是真正的数据值
如果参数是引用数据类型，传递的是地址


public class Test{


    public void say(int num){
        num = 20;
        System.out.println(num);
    }
    public static void main(String[] args){
        Test  test  =  new Test();
         int num = 10;
         test.say(num);
         System.out.println(num);
    }
}
打印结果为：20，10
结论：基本数据类型作为参数，在方法内部改变参数的值，不会影响到外部
打印结果为：20，20
结论：引用数据类型作为参数，在方法内部改变参数的状态，会影响到外部
public class Test{
    public void  say(StringBuffer  strb){
        strb = new  StringBuffer(“bbb”);
        strb.append(“ccc”);
        System.out.println(strb.toString());
    }


    public static void main(String[] args){
        Test  test  =  new Test();
        StringBuffer strb = new StringBuffer(“aaa”);
        test.say(strb);
        System.out.println(strb.toString());
    }
}
结果：aaaccc，aaa
结论：引用数据类型作为参数，在方法内部改变了引用对象，不会影响到外部




class T{
    int num = 10;
}
public class Test{
    public void  say(T t){
        t = new  T();
        t.num = 20;
        System.out.println(t.num);
    }


    public static void main(String[] args){
        Test  test  =  new Test();
        T t = new T();
        test.say(t);
        System.out.println(t.num);
    }
}
结果：20，10
结论：引用数据对象作为参数，在方法内部改变了对象，不会影响到外部


冒泡排序：
for(int i=1;i<5;i++){
 for(int j=4;j>=i;j--){
  if(num[j]<num[j-1]){
   int temp=num[j-1];
   num[j-1]=temp;
  }
 }
}