|
Java是一门比较简单的语言，简单成为了Java发展迅速的原因之一
Java是一门为数不多的多线程语言 Java是一门面向对象的编程语言 Java提供了垃圾的自动回收机制（GC） Java避开了复杂的指针问题，而采用引用的方式进行对内存的操作 Java可以实现任意平台的跨越。 ·Java的编译器将源文件编译成字节码文件，之后再交给JVM ·Java的解释器负责将class文件在特定的平台上解释运行 path：是操作系统的一个属性，该属性是一些可执行文件（或者）程序路径。 classpath:是在Java解释程序的时候，需要加载*.class文件的路径 数据的类型 Java的数据类型分为两类：基本数据类型和引用数据类型 -基本数据类型 ·整形：byte、short、int、long 默认值是0 ·浮点类型：float、double 默认值是0.0 ·字符型： char 默认值是\u0000 ·布尔类型：boolean 默认值是false -引用数据类型：数组、类、接口 默认值是null 基本数据类型不牵涉到内存分配问题，而引用数据需要分配内存空间 表示整数使用int 表示小数使用double 实现日期数字或者文件大小使用long 实现数据传递或者编码使用使用byte 实现逻辑控制使用boolean描述 在编程的世界里，大范围的数据和小范围的数据进行四则运算，小范围的数据会自动转换为大范围的数据再进行计算，如 果范围大的数据要想 变为小范围的数据，那么就用强制类型转换。 不要相信默认值，因为在方法中默认值是无效的所以再开发中应该手动给定默认值，char类型和int类型的数据能相互转化 是因为每一个字符都有一个编码 （Unicode），在特定的编译环境中有一些字符有特殊意义，要取消它的特殊意义就得使用转义字符。\f 换页、\b退一格 、\'单引号、\t制表符、\\反斜线 \r归位、\"双引号、\n换行 运算符 ·算术运算符 %、 ++、 --、 =、+、-、*、/、+=、-=、*=、/=、%= ·逻辑运算符 ||：逻辑或运算，如果第一个条件返回true，就不再会执行判断第二个条件 使用“|”来代替“||”，“|”可以当作或运算符使用还可以当作位运算符使用 &&：逻辑与运算，只有两个条件都返回true的时候最终结果才是true，否则是false 使用“&”来当作逻辑与运算使用，还可以当作位运算符来使用 ·三目运算符 语法：condition?value1:value2; -如果condition返回true那么整个三目表达式返回value1（第一个值） -如果condition返回是false那么整个三目表达式返回value2（第二个值） 表达式:表达式就是由一个或者多个操作数再加上操作符有规律组合起来的式子叫做表达式， 表达式一般要返回一个布尔类型的值 。 循环 三种循环 ·for循环 基本的语法： for(变量的初始化;条件判断;变量的更新){ 循环体 } 步骤： ①变量的初始化 ②条件判断，如果满足条件执行循环体，之后进如③，如果不满足条件，终止循环 ③变量更新，进入② ·while循环 while(condition){ 循环体（包含一个变量更新的语句） } ·do while循环 do{ 循环体（包含一个变量更新的语句） }while(condition); while和do{}while循环的区别：后者不管条件是否满足都会执行一次。 while和for的区别：for循环可以完成的功能while循环一定可以完成，反之不行 当知道循环次数的时候首选for循环，当不知道循环次数的时候选while。 break、continue、lable关键字的用法 ·break:当执行到break的时候，break后面的代码不在被执行，并且不再会开启下一次循环（除非有外层循环控制），终止整个循环 ·continue:执行到continue时候，后面的代码不会被执行，但是会开启下一次循环，也就是说只会终止当次循环 ·break和continue只会对离他最近的循环有效。 ·lable 标记 跳出循环跳到标记的位置。 字符串的方法 实例化的两种方法 -直接赋值：会在堆内存中开辟一块空间，并且自动入池 -构造方法：会在堆内存中开辟两块内存空间，不会自动入池，要实现入池，要使用intern（） 替换满足条件的字符串内容 ·public String replaceAll(String regex,String replacement）替换所有满足条件的字符串 ·public String replaceFirst(String regex,String repalcement) 替换满足所有条件的第一个字符串 截取字符串的内容 ·public String substring(int beginIndex)截取从指定索引开始以后的所有内容 ·public String substring(int beginIndex,int endIndex)截取指定开始索引到结束索引的内容 字符串的拆分 ·public String[] split(String regex)根据指定的字符拆分成字符串数组 ·public String[] split(String regex,int limit)根据指定的字符标记拆分，拆成指定大小的数组 部分拆分 //对于一些敏感字符的拆分要使用转义之后才能拆分，如："\\|"、"\\." 将字母大小进行转换 ·public String toLowerCase()将大写字母变成小写 ·public String toUpperCase()将小写字母变成大写 ·public String trim()取消字符两端的空格，中间的空格不会被取消 String对象不能频繁的被改变，会产生大量的垃圾。匿名对象有堆内存，没有栈内存。将匿名对象放到前面可以避免空指针异常 引用数据的传递 一块堆内存空间可以被多块栈内存地址指向 一块栈内存只能指向一块堆内存空间 StringBuffer的方法 -构造方法： ·public StringBuffer (String str) -实现字符串的追加 ·public StringBuffer append(String str) -实现字符串的反转 ·public StringBuffer reverse(String str) -在指定位置增加数据 ·public StringBuffer insert(int offset,String str) -删除部分数据 ·public StringBuffer delete(int start,int end) String申明之后内容不可变，StringBuffer考虑了线程安全，而StringBuilder没有考虑线程线程安全 在字符串修改频率高的时候使用StringBuffer(内存溢出问题) 接口 如果一个类中只有全局常量和抽象方法，但是没有构造方法，那么这个类就是接口，在接口中可以定义静态方法，但是没有意义 ·实例变量：在类中声明但是没有使用static修饰的常量 ·静态变量：（类变量）在类中声明但是使用了static修饰的常量 ·局部变量：在方法中声明的变量，一旦方法被执行完就会被销毁 ·全局常量：在类中声明，并且使用static和final修饰的变量 接口要有意义就必须被子类实现，要使用interface关键字，如果子类不是抽象类，那么要实现接口中的所有抽象方法 接口解决了单继承的局限性可以多实现，接口之间也可以使用继承关键字extends,接口也可以实现向上转型 继承 继承解决了代码的重复问题，在实例化子类的时候会默认调用父类的构造方法，如果定义了有参的构造方法那么无参的就不存在了 父类封装的属性可以被子类继承，这样的继承被称为隐式继承。 覆写与重载 覆写（override)表示方法的重写 -方法名，参数列表，返回类型相同 -发生在继承关系中 -子类不能拥有比父类更严格的访问权限 重载（overload）表示方法的重载 -方法名相同，参数列表不同 -对返回值没有要求，但是再开发中返回值要求保持一致 -对访问权限没有要求，但是在开发中要求保持一致 方法的递归 -方法你的递归就是方法自己调用自己 多态 多态实现了类参数的统一，要实现多态就必须以继承或者实现为基础，那么多态的表现形式有两种： -方法的多态：重载，重写 -对象的多态：向上转型，向下转型 ·向上转型：父类 变量=子类实例化对象 ·向下转型：子类 变量=（强转）父类对象【先必须实现向上转型】 多态机制的原理：可以使用父类或者接口的引用变量指向具体子类的实例化对象，在程序调用方法时是在运行时 动态绑定的，所绑定的方法是具体子类或者实例对象中的方法，而不是引用类型中的方法 向下转型存在类型转换错误的风险，用instanceof关键字来判断一个类是否是它的子类，如 person instanceof Student 抽象类 抽象类有自己的构造方法，但是不能实现不能直接实例化对象，如果子类不是抽象类，那么子类必须覆写抽象类的所有方法 抽象类可以没有抽象方法，但是有抽象方法的一定是抽象类或者接口，在开发中抽象类可以设计成模版模式 静态属性 static定义的属性就是静态属性，静态属性不依赖实例化对象的存在，可以使用类名.属性名调用。静态方法中不能访问 非静态属性、非静态方法，静态方法中不能使用this关键字，非静态方法可以访问静态方法。 Date对象 Date类的方法 ·构造方法： -public Date() -public Date(Long date)传递一个long类型的参数 ·获取时间： -public long getTime()以long类型返回 long cur=System.currentTimeMillis();//获取从1970年1月1日到当前的毫秒数 日期格式化对象（SimpleDateFormat） ·构造方法： -public SimpleDateFormat(String pattern)//参数是我们需要的格式"YYYY-MM-DD HH:mm:ss.SSS" ·格式转换： -public final String format(Date date)//将Date类型转变成String类型日期 -public Date parse(String sourse)//将String类型日期转变成Date类型 sdf.setLenient(false);//开启严格模式 泛型 泛型<T>通配符？有两个子通配符分别是？extends类，？super类 ？extends类：可以用于类的泛型，也可以用于方法的泛型;是设置范型的上限，一旦为类设置范型上限，那么实例化 子类的时候只能是泛型上限所对应的类或者子类 fun(Message<?extends Object> msg); ？super 类：只能用于方法参数的泛型，能接受的参数的泛型只能是该类或者该类的父类 fun(Message<?super integer> msg); 新泛型 如果要定义一个方法可以接受任意个数的参数，这里就可以用新泛型来实现public static <T>T[] fun(T...temp) {return temp;} 异常 Eorr和Exception都是Throwable的子类 Eorr:是程序还没有运行之前就出现的错误，是JVM出现的错误是不能通过捕获处理的 Exception:是程序在运行中出现的异常，是可以通过捕获处理的。 程序出现了异常JVM会自动实例化一个对应的异常对象，再判断是否存在异常的捕获语句 throws关键字放到方法名后面，一旦方法中使 用了关键字，那么在该方法中出现的异常，将会向上抛出，交给调用处去处理该异常。 throw关键字位置是在方法体中，手动抛出异常。 Exception是异常要求强制处理的，RuntimeException不要求强制性处理，可以选择性的处理 断言 assert关键字是在jdk1.4版本引入的表示断言 assert num==20; (num的值是20) 线程与进程 进程是线程的载体，一个进程由多个线程组成，线程要依附于线程，一旦进程关闭，那么线程就不存在了。 系统要区分线程是通过线程的名字来区分的，那么如何设置和获取线程的名字呢？ -public final String getName()获取线程的名字 -public final void setName(String name)设置线程的名字 -public Thread（Runnable target，String name）初始化线程，并设置名字 -Thread.currentThread().getName() 获取正在运行的线程的名字 在使用Java命令运行一个Java程序时，JVM会启动一个进程，这个进程至少就会启动两个线程 -主方法是一个线程 -GC垃圾回收线程 线程的休眠 Thread.sleep（毫秒数）; 线程的优先级 线程有三种优先级，原理上是优先级越高那么线程就越先执行，但这仅仅是可能是不一定 ·高优先级：public static final int MAX_PRIORITY=10 ·中等优先级：public static final int NORM_PRIORITY=5 ·最低优先级：public static final int MIN_PRIORITY=1 -设置优先级 public final void setPriority(int newPriority) -获取优先级 public final int getPriority 多线程的实现 要实现线程，在JDK1.5之前有两种方式 ·继承Thread类，Thread类是一个支持线程操作的类，只要是该类的子类都可以实现多线 程的所有操作 ·实现Runnable接口 在JDK1.5之后提供了Callable接口也可以实现线程的操作，但是目前在开发中一般使用前面 两种 一个Java程序的起点是main方法（其实也叫主线程），在main方法中启动的其他线程叫做之子线程，理所当然它们也有自己的起点方法，这个起点方法就是run方法，run()需要覆写，在启动之后并没有体现多线程的并发性，而是有序的，根本原因是使用run（）启动线程的， 所以在启动线程的时候要使用start（）方法。 start()方法 start（）方法在启动时调用start0()方法，该方法没有方法体，类似于一个抽象方法，使用 native,在Java的开发中有一种技术叫 做JNI（Java Native Interface)技术，该技术是使用Java程序调用本地操作系统的函数，我们在启动线程的时候，操作系统必须为每一个线程分配资源，那么在分配的时候由于操作系统的支持性不同，所以每一种操作系统分配资源方式不一样，那么start0（）方法就不能写死，只能定义出一个标准，具体分配实现方式有JVM根据操作系统的不同实现不同的分配方式，这也是表现Java的可移植性的表现之一。 要启动多线程就必须使用start（）方法，start（）方法中调用start0（）完成资源的分配 之后系统再自动调用run()方法。 Runnable接口 在Runnable接口中并没有start（）方法，但是在Thread构造方法中，我们可以将Runnable接口作为参数传递过去。public Thread （Runnable target）{} 继承Thread：这种方式有单继承的局限，而且不能方便的实现线程之间的数据共享 实现Runnable接口:没有单继承的局限，而且能方便的实现数据之间的共享，实现多线程，使用实现Runnable接口的方式是最好的。 线程的同步 如果线程不同步，那么多个线程访问统一数据的时候就会出现风险 -使用同步代码块 语法：synchronized(this){...} -使用同步方法 语法 public synchronized void run(){...} 同步的负面效应 ·使用同步，那么代码的执行效率就会降低，因为当前线程要等待上一个线程执行完毕之 后才能执行。 ·使用同步，有时候会出现死锁现象（但是这个概率非常小） 多线程的生产者，消费者模式
class PublicBox {
//产品
private int apple = 0;
public synchronized void increace() {
while (apple ==5) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple++;
System. out .println("生成苹果成功！" );
notify();
}
public synchronized void decreace() {
while (apple ==0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple--;
System. out.println( "消费苹果成功！" );
notify();
}
}
class Producer implements Runnable {
//生产者
private PublicBox box;
public Producer(PublicBox box) {
this .box = box;
}
@Override
public void run() {
for( int i=0;i<10;i++){
try {
System. out .println("pro i:" +i);
Thread. sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
box.increace();
}
}
}
class Consumer implements Runnable {
//消费者
private PublicBox box;
public Consumer(PublicBox box) {
this .box = box;
}
@Override
public void run() {
for( int i=0;i<10;i++){
try {
System. out .println("Con: i " +i);
Thread. sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
box.decreace();
}
}
}
public class Test{
public static void main(String []args) {
PublicBox box= new PublicBox();
Consumer con= new Consumer(box);
Producer pro= new Producer(box);
Thread t1= new Thread(con);
Thread t2= new Thread(pro);
t1.start();
t2.start();
}
}
当一个线程访问一个对象的同步方法的时候，如果该线程进入方法之后使用sleep方式休眠，那么在休眠期间其他任何线程不能访问该对象的任何同步方法，也就是说sleep在休眠的时候是不会释放锁的。 当一个线程进入一个对象的同步方法之后使用wait方式休眠的情况下，在休眠的期间，其他线程可以访问该对象的所有同部方法，也就说使用wait方法休眠的线程可以释放锁 ·sleep: |-sleep()是Thread的方法 |-使用sleep休眠的线程会自动醒来 |-使用sleep休眠的线程不会释放锁 ·wait(): |-wait()是Obejct类中的方法 |-使用wait休眠的线程需要使用notify或者notifyAll方法唤醒 |-使用wait休眠的线程会释放锁。 请分析一下代码输出“A”和“B”各多少次？ class Productor implements Runnable{ @Override public void run() { for(int i=0;i<50;i++){ try { Thread.sleep(300); } catch (InterruptedException e) {
e.printStackTrace(); } System.out.println("A"); } } } class Customer implements Runnable{ @Override public void run() { for(int i=0;i<50;i++){ System.out.println("B"); } } } public static void main(String[] args) throws Exception { Thread th1=new Thread(new Productor()) ; Thread th2=new Thread(new Customer()) ; th1.setDaemon(true);//及A设置为守护线程 th1.start(); th2.start(); } } 答：以上代码输出“A”是不确定， 输出“B”是50次 原因是输出A的线程是守护线程，B的线程是非守护线程（用户线程） 守护线程为非守护线程而服务，所以当JVM中如果没有非守护线程的时候，所有的守护线程都会结束， 以上的代码A是由守护线程输出，B是由非守护线程输出，所以A的次数是不定的，B的次数是50固定的 我们最常见的典型的守护线程是CG垃圾回收线程。 在Java中存在一个类"Java.lang.Class",这个类可以为每一个实例化一个Class类型的对象， 也就是说每一个类都有一个相对应的Class的实例化对象 为一个类（A）实例化一个Class对象有三种方法： ·使用继承Object类的一个getClass（）方法 public final Class getClass()方法 ·使用"类.Class"的方式实例化一个Class对象，也就是A.Class ·使用Class类中的一个静态方法 public static Class forName（String className） 该方法必须知道类的全名称（包名.类名） 反射的简单应用 我们可以使用反射实例一个类的实例化对象，要实现这一操作，需要使用Class中的一个方法： public T newInstance() T t =null; Class<?> cls=Class.forName(ClassName); t=(T)cls.newInstance（）; 反射调用构造方法 ·获取有参数的构造方法 -获取指定的构造方法：public Constuctor getConstructor(Class...parameterTypes) -获取所有的构造方法 ：public Constuctor[] getConstructors() 反射调用普通方法 ·获取指定的方法：public Method getMethod(String name,Class... parameterTypes) ·获取所有的方法：public Methods [] getMethods() ·方法的调用：使用invoke()方法 反射对属性的操作 要对属性操作需要先获取属性，之后再设置属性 ·获取指定的属性：public Filed getDeclaredFiled(String name) ·取消封装：Filed.setAccessible(true); 反射可以将简单Java类对象的属性以及属性值组装成Json字符串 比如："Person":{name="张三"，"address":东莞，"age":100}这就是Json格式 Class<?> cls=Class.forName("NewInstance.Person"); Person per=(Person) cls.newInstance(); per.setAddress("东莞"); per.setName("张三"); per.setAge(100); StringBuffer sb=new StringBuffer("\"Person\":{"); Field [ ]fs=cls.getDeclaredFields(); for (int i = 0; i < fs.length; i++) { fs[i].setAccessible(true); sb.append("\""+fs[i].getName()+"\""); sb.append(":"+fs[i].get(per)+","); } sb.append("}"); System.out.println(sb); 文件的操作 要学习io知识，首先要学习Filed类，这是一个对文件操作的类，但是不会操作文件的内容 操作文件 ·构造方法：public File（String pathName）pathName是文件目录+文件名 ·创建文件：public boolean createNewFile()throws IOException ·创建文件目录（文件夹） -创建一级目录：public boolean mkdir()创建成功返回true -创建多级目录：public boolean mkdirs()创建成功返回true 判断目录是否存在 ·先取出父路径：public File getParentFile() ·判断文件的目录是否存在；public boolean exists() 文件删除：public boolean delete() *由于操作系统的不同文件分隔符也不相同，例如windows系统的为"\",Linux支持的是"/" 所以我们需要动态的取出说支持的分隔符 public static final String separator//File.separator 取得文件的信息 ·取得文件的大小：public long length()取得文件的大小，以字节为单位返回 ·获取当前文件下的第一级目录，以String类型数组返回：public String[]list（） ·获取当前文件下的第一级目录，以File数组类型返回：public File[]listFiles() ·获取盘符下所有的文件列表：public static void printDirs(int level,File file) ·判断是否是目录：public boolean isDirectory() 文件内容的操作 读取或者写入数据的时候是按照流的方式进行操作的 -字节流（以字节【byte】为单位进行操作） -字符流 (以字符【char】为单位进行操作) 实现数据的输出：public abstract class OutputStream{} ·进行输出内容（向指定文件中写入内容）：public void write(byte[] b) [先将数据转换成字节保存在字节数组中] ·进行单个字节输出：public abstract void write（int b） [每次输出一个字节，要将数据内容全部输出要使用while循环] ·输出部分字节数组：public void write(byte[] b,int off,int len) [off表示要从数组第几个下标开始输出，len表示输出多少个字节数] 使用字节流的操作，要遵循下面的步骤： ·定义一个文件路径 ·实例化OutputStream的子类对象FileOutputStream ·进行输出操作 ·因为流是一种资源，必须关闭 *在实例化OutputStream的子类对象会覆盖原有的内容，如果要实现追加则使用另外一个 构造方法 OutputStream out=new FileOutputStream(file,true); 实现数据的输入：public abstract class InputStream{} ·每次读取一个字节，返回值是int类型：public abstract int read() [使用该方法要使用while循环读取] ·每次读取一个数组长度的数据：public int read(byte[] b) [返回值，如果还有数据则返回读取到数据的长度，否则返回-1] ·每次读取指定长度的数据：public int read（byte[] b,int off,int len ） [返回值，如果还有数据则返回读取到数据的长度，否则返回-1] *一般字节流使用来读取：视频、音乐、图片等等，而字符流对中文操作。 字符输出流 字符流也同样需要为两个抽象类Writer，Reader实例化两个子类FileWrite和FileReader ·输出字符数组的内容：public void write（char[] c） ·输出单个字符：public void write(int c) ·输出一个字符串：public void write（String str） ·每次读取一个字符：public int read() ·每次读取一个数组长度的数据：public int read（char[] c ） ·每次读取部分数组的长度:public int read(char[] c,int off,int len) [第一个参数是一个字符数组，用来保存读取到的内容，第二个参数是规定从数组的第off个下标开始，第三个参数是数组的长度] ·字节流操作数据以字节为单位，字符流是一字符为单位 ·字节流直接对终端进行操作，而字符流需要经过缓冲区的处理之后才能操作 ·基于第二个原因操作字节流的时候如果没关闭也不受到影响而字符流则不会输出使用flash ·在开发中一般将数组长度定义为1024或者2048. Collection接口的操作方法 Collection是单值集合的最大父接口，即：每次只能保存一个元素（单值） public boolean add(E e):向集合中添加元素 public boolean addAll(Collection<?extend E> c):向集合中追加一个集合 public void clear（）：清空集合 public boolean contains(Object o):判断集合是否为空，空不是指null public Iterator Iterator（）：为Iterator接口实例化子类对象，用于遍历集合 public boolean remove（Object o）:删除某一个元素，需要equals（）的支持 public int size():取得集合的大小 Collection是最大的父接口，下面有两个常用的子接口List和Set， 而List接口有两个常用的实现它接口的子类arrayList和Vector,而Set接口有两个常用的实现它的子类HashSet和TreeSet。 一般都不使用Collection接口，而使用其子接口。 List接口： 在该接口中有扩充了一些重要的方法 public E get（int index）【根据下标获取指定的元素】 public E set (int index,E element)【设置指定下标的元素的值，就是替换值】 ArrayList和Vector ArrayList是新的子类，在JDK1.2版本增加（1998年），Vector是旧的子类，ArrayList 没有考虑线程安全，性能比较高，Vector考虑了线程安全，性能相对比较低 HashSet保存数据是无序的（由子类决定），重复的数据不能保存（父接口不能保存） 如果存在信息重复说明没有hashCode()和equals()方法，任何对象比较都用这两个方法 其中String类中还有一个compareTo()自动排序方法 HashSet保存的数据是无序的，元素不能重复。 TreeSet保存的数据是有序的都应该提供hashCode，equals，compareTo方法 Java的三种基本模式 ·工厂模式 interface IFruit{//定义一个主题 public void eat(); } class AppleImpl inplements IFruit{ public void eat(){ system.out.print("吃苹果"); } } class OrangeImpl inplements IFruit{ public void eat(){ system.out.print("吃橘子"); } } class Factory{ public static IFruit getInstance(String className){ IFruit i=null; Class<?> cls=Class.forName(className); i=(IFruit)cls.newINstance(); return i; } } ·代理模式 interface ISubject{//这是一个真主题 public void sing(); } class ProxySubject{//这是一个代理 private Subject sub; public ProxySubject(){} public ProxySubject(Subject sub){ this.sub=sub; } public void prepare(){ system.out.print("唱歌前的准备工作"); } public void destory(){ system.out.print("唱歌后的收尾工作"); } public void make(){ this.prepare(); this.sub.sing(); this.destory(); } } class HuaZaiImpl implements Subject{ public void sing(){ system.out.print("华仔唱歌"); } } public class Demo{ public static void main(String [] args){ ProxySubject psj=new ProxySubject(new HuaZaiImpl); psj.make(); } } ·单例模式 -饿汉式 class Sigleton{ private Sigleton(){} private static final Singleton INSTANCE =new Singleton(); public synchronized static Singleton getInstance(){ return INSTSNCE; } } -懒汉式 class Singleton{ private Sigleton(){} private static Singleton instance; public synchronized static Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance; } } 集合的输出 集合的输出有四种： ·使用Iterator接口实现输出 -iter.hasNext() ·使用ListIterator接口实现输出，这种方式只适合List接口 -liter.hasNext() 实现正向输出 -liter.hasPrevious() 实现反向输出（实现反向输出，要先实现正向输出） ·使用加强for循环输出 -for(T t:set){} ·使用Enumeration接口输出，这种方式只是Vector -enu.hasMoreEkements() 集合的输出首选iterator方式（90%） Map集合 在保存一对（key=value）为单位的时候 ，我们可以使用Map接口来完成 ·public V put(K key ,V value):向集合中添加某一个元素 ·public V get（Object key）:根据指定的key取得对应的value值 ·public Set<K> KeySet():获取集合中所有的key，保存到Set集合中返回 ·public Set<Map.Entry<K,V>> entrySet():嵌套映射 返回映射中包含映射关系的集合 HashMap保存的数据没有顺序，如果key值重复，那么新的值会覆盖旧的值 HashMap是新的子类，在JDK1.2版本推出，Hashtable是旧的子类 HashMap没有考虑线程安全，性能较高，Hashtable考虑了线程的安全，性能相比较低 HashMap保存的key或者值可以为null,Hashtable保存的key或这value都不能为空 使用自己自定义的类型作为key,那么要为对应的类提供hashCode（）和equals（） 在开发中一般使用String类型作为key值 要输出Map 集合要用entrySet转换成Set ，在集合保存的时候，会自动将key和value 这一对值封装为Map.Entry类型的对象在调用的时候就是用"外部接口.内部接口" 数据库的连接 Oracle的准备连接信息 DRIVER="oracle.jdbc.driver.OracleDriver"; URL="jdbc:oracle:thin:@localhost:1521:orcl"; USER="scott"; PASSWORD="tiger"; MySQL的准备连接信息 DRIVER="com.mysql.jdbc.Driver"; URL="jdbc:mysql://localhost:3306/MySQL"; USER="root"; PASSWORD="1234"; |
正在加载中...
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
