Java
老师: 周海 马政
Write Once,Run Anywhere!
- Java介绍
- 第一代语言
- 第一代语言或机器语言是一种低级的面向计算机的程序设计语言,使用0和1表示各种命令。
- 第二代语言
- 汇编
- 第三代语言
- C、Pascal、Fortran面向过程的语言
- C++面向过程/面向对象
- Java跨平台的纯面向对象的语言
- .NET跨语言的平台
- Java是sun(Stanford University Network) 公司,1982年成立,java的主要设计者是James Gosling,来源一个为电子消费产品项目Green。
- 95年,Sun发布JDK1.t0
- 98年,JDK1.2,更名为Java2
- 后续JDK1.3、1.4
- JDK1.5,更名为Java 5.0
- 我们使用jdk1.6
- 最新版jdk1.7
- ……
- Java一种健壮的语言,吸收了C/C++ 语言的优点,但去掉了其影响程序健壮性的部分(如:指针、内存的申请与释放等)。
- 简洁有效
- 可移植性
- 面向对象
- 解释型适合分布式
- 具有多线程处理能力
- 具有较高的安全性
- 是一种动态语言(可以将代码插入到正在运行的程序中)
- Software Devleopment Kit (软件开发包)
- Java Runtime Environment (Java运行环境)
- 开发需要JDK Java Devleopment Kit
- 用户只需JRE Java Runtime Environment
- 安装完需要配置环境变量
- Path JDK中的bin文件路径
- classpath 设置字解码环境变量,字解码文件的执行路径
- ‘.’ 在路径上表示当前目录
- Java_home JDK的根目录
- 最主流的是Sun公司发布的JDK
- 除了Sun之外,还有很多公司和组织都开发了自己的JDK
- IBM公司开发的JDK, IBM的JDK包含的JVM(Java Virtual Machine)运行效率要比Sun JDK包含的JVM高出许多
- BEA公司的Jrocket,专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多
- GNU组织开发的JDK
- 现在andr手机开发使用的是Google公司的JDK
- Java跨平台依于JVM虚拟机 -Java Virtual Machine
- Java所有代码写在类中,类名大写
- 一个Java可以定义多个类,但不同类会生成不同的class文件
- 只能有一个public类,并且类名要与文件名相同
- Java严格区分大小写哦
- 编写完后在cmd\终端中编译javac file_name.java
- 编译完后产生file_name.class文件,为字解码文件
- Java两种核心机制:
- Java虚拟机 Java Virtual Machine
- Java虚拟机可以理解成一个以字节码为机器指令的 CPU。
- 对于不同的运行平台,有不同的虚拟机。
- Java 虚拟机机制屏蔽了底层运行平台的差别,实现了“一次编译,随处运行”。
- 垃圾收集机制 Garbage Collection
- 不再使用的内存空间应回收-垃圾收集。
- 在C/C++ 等语言中,由程序员负责回收无用内存。
- Java语言消除了程序员回收无用内存空间的责任;它提供一种系统级线程跟踪存储空间的分配情况。并在JVM的空闲时,检查并释放那些可被释放的存储器空间。
- 垃圾收集在Java程序运行过程中自动进行,程序员无法精确控制和干预。
- Java注释:
- // 当行注释
- /*
多行注释
- */
- /**
文档注释,且可被doc工具解析
- */
- 在cmd/终端输入java -version 查看JDK版本
- Java -verbose file_name 查看执行class文件的过程
- Java基础
- 标识符:Java语言中,对各种变量、方法和类等要素命名时使用的字符序列
- 由字母、下划线_ 、美元符号$或数字组成
- 以字母、下划线、美元符号开头
- 区分大小写,长度无限制
- 应注意“见名知意”且不能与Java的关键字同名
- Java所有关键字都是小写英文字符串
- 变量:最基本的存储单元,包括变量名,变量类型,作用域
- Java每一个变量都属于特定的数据类型,在使用前必须对其声明
- 例:int i = 10;
- float = 12.3f;
- 从本质来讲,变量为内存中的一小块区域,使用变量名来访问这块区域,因此每一个变量使用前必须先声明,然后赋值
- 按被声明的位置划分:
- 局部变量:方法或语句快内部定义的变量,可以不用初始化赋值,有默认值(byte-0、short-0、int-0、long-0L、float-0.0L、double-0.0d、char-\u0000、boolean-false)
- 成员变量:方法外部、类的内部定义的变量,必须初始化进行赋值
- 按所属的数据类型划分:
- 基本数据类型变量
- 数值型
- 整数类型(byte、short、int、long)
- 在定义long变量时在值后加L
- 在定义float变量时在值后加F
- 字符型(char)
- 布尔型(boolean)
- 整数类型(byte、short、int、long)
- 数值型
- 引用数据类型变量
- 类(class)
- 接口(interface)
- 数组
- Java字符采用Unicode编码,每个字符占用两个字节,因此可用十六进制编码形式表示,Java支持汉子做类名、函数名和变量名
- byte、short、char -> int -> long -> float -> double
- byte、short、char之间不会互相转换,他们三者在计算时首先会转换为int类型
- 容量大的数据类型转换为容量小的数据类型时,要加上强制转换符,但要注意造成精度降低或溢出
- Java运算符:
- 算术运算符: + , - , * , /(整除) , %(取模,取余数) , + + , - -
- + + number :先加,再参与所在表达式运算
- number + + :先参与所在表达式运算,后加
- 关系运算符:> , < , >= , <= , = = , ! = , = = =
- = = :值相等就可以
- = = = :数据类型要相等才可
- 逻辑运算符 : ! , & , | , && , | |
- int a = 3;
- int b = 2
- int a = 3 & & int b =2
- & & : 短路与,前错便不再运算后
- int a = 3 | | int b =2
- | | : 短路或,前对便不再运算后
- 位运算符:& , | , ^(异或) , ~(取反) , > >(右移) , < <(左移) , > > >(无符号右移,用0填充)
- & : | :
- int a =2 int a = 2
- int b = 3 int b = 3
- 1 0 = 2 1 0 = 2
- & 1 1 = 3 | 1 1 = 3
- ——————— ————————
- 1 0 = 2 1 1 = 3
- a & b = 2 a | b = 3
同1为1 有1为1
- ^: ~ :
- int a = 2 int a = 2
- int b = 3 int b = 3
- 1 0 = 2 ~3 = -4
- 1 1 = 3 补码=源码+取反+加1
- ——————— 负数以补码形式
- 1 = 1
相等为0
不同为1
- >> : << : >>> :
- 2 1 用0补符号位
- ……010 ……001 负数变为正
- >> <<
- ……001 ……010
- 1 2
- 正负数符号位不变
- 表达式优先级问题,用括号处理
- 三目运算-条件表达式:
- int score = 2;
- String grade = score < 60 ? “不及格”: “及格”;
- For循环
- for(__;__;__){
}
- while & do while
- while( ){ do{
} }while( )
- break (跳出本次循环); continue (结束当此循环);
- 方法
[修饰符1,修饰符2…] 返回值类型 方法名(形参){
}
- 方法重载:方法名相同,参数个数或类型不同,方法重载和返回值无关
- 递归调用
- 数组
- 一维数组
- int a[] = new int[3] 数组名为首地址,为hc编码常量
- public void setName(String name){
- this.name = name this代表的是当前对象实例
- }
- 二维数组,由多个一维数组组成
- Java中,二维数组的列数可以不一样
- 二维数组名.length 为二维数组的行数
- a[i].length i行的长度
- 定义 : int [ ] [ ] b = new int [3] [ ] 列可以不写,不写死范围
- 类 Arrays 工具类 (API查找)
- sort ( ) 排序 要饮用包调用工具类 import java.util.Arrays;
- copyofRange ( ) 复制数组
- 数组的比较
- int[] a = { };
- int[] b = { };
- a = = b 此类比较的为地址比较
- Arrays.equal(a,b) 数组大小的比较(内容比较)
- 饮用类型赋值时赋的为地址值
- Java新特性
- 可变参数
- public void text(int …args){
- //args是数组
- foreach 输出 (关键字为for)
- public void text (int … args){
- for(int x : args){
- System.out.println(x)
- }
- }
- 输入问题
- pbulic static void main(String[] args) //接受外部输入的参数
- 使用输入流
- 先用引包 import java.util.*;
- 然后 Scanner in = new Scanner (Scanner.in); Scanner 类
- num = in.nextInt();
- 生成说明书
- Javadoc -d doc_name DocDemo.java
- javac -d doc_name -authoe -version DocDemo.java
- 生成的类必须为公有的
- 面向对象
- 对象通过属性和方法来分别对应事物所具有的静态和动态
- 开发:
- 首先考虑有哪些类来找对象
- 其次要做哪些功能由谁来功能
- 面向对象的特质
- 封装(encapsulation):
- 继承(inheritance):
- 多态(polymorphism):
- 构造函数:
- 函数名与类名相同
- 不用定义返回值类型
- 不用写return语句
- //如果没有有参的构造方法,系统会自动创建一个无参数的构造方法
- 注意:一旦人为定义了有参数的构造方法,系统就不再闯进无参的构造方法
- 一个成员变量有了set get方法后可以称为属性
- 一般写两个,一个无参,一个全部参赛属性的构造函数
- this指当前对象实例,指当前构造函数,由后面参赛确定
- this调用只能放在构造方法的第一行
- new ->实例化对象
- String
- 由于String 太常用,对String作了优化
- String info1 = “好人”
- String info2 = “好人”
- 以这种方式创建实例,如果值相同那地址就相同
- equals
- String username = “haoren”; String username = “haoren”;
- if(username.equals(“haoren”)){ if(“haoren”.equals(username)){
- System.out.println(“yiyang”): System.out.println(“yiyang”);
- } }
- 使用equals将匹配的值放前,可以避免空指针异常
- 异常不等于错误
- charAt()
- String name = “我是好人,你是吗?”
- System.out.println(name.charAt(4));
- //输出 ,
- matches 验证字符中是否匹配正则表达式
- String email = “haoren@sina.com”;
- if (email.matches( “ “ )){
- }
- 转义字符:有特定字符被系统占用,有特殊意义
- split() 分割
- public class Text{
- public static void main(String[] args) {
- String hobby = "睡觉,足球,跑步,打豆豆";
- String[] hby = hobby.split(",");
- for(String x:hby){
- System.out.println(x);
- }
- }
- }
- startsWith() 判断以什么开头
- public class Text{
- public static void main(String[] args){
- String name = "我是好人";
- System.out.println(name.startsWith("我"));
- }
- }
- true
- endsWith() 判断以什么结尾
- public class Text{
- public static void main(String[] args){
- String name = "我是好人";
- System.out.println(name.endsWith("人"));
- }
- }
- true
- String Buffer() 连接 需要进行字符串的反复拼接使用StringBuffer,速度快, //buffer缓冲区
- public class Text{
- public static void main(String[] args){
- StringBuffer sb = new StringBuffer("haoren");
- sb.append("i");
- System.out.println(sb);
- }
- }
- haoreni
- int a = 23;
- String s = a + “”;
- 快速变字符串
- trim() 去掉两边空格
- public class Text{
- public static void main(String[] args){
- String name = " haoren ";
- String a = name.trim();
- System.out.println(a);
- }
- }
- haoren
- 类名首字母大写,方法第二个字母大写
- replace() 替换
- public class Text{
- public static void main(String[] args){
- String a = "haoren";
- System.out.println(a.replace("haoren","huairen"));
- }
- }
- huairen
- 返回数组
- public int[] text(){
- int a;
- int b;
- return b;
- static
- 方法只在内存中存一份(代码区)
- 栈stack 堆heap 静态存储区 代码区
- static 用于修饰成员(成员变量和成员函数)修饰成员变量时,可以实现数据共享
- static 修饰后的成员:
- 随着类的加载而加载
- 优先于对象存在
- 被所有对象所贡献
- 可以直接被类名所调用
- 注意:
- 静态方法只能访问静态成员
- 静态方法中不可以写this,super关键字
- 主函数是静态的
- static是一个修饰符,用于修饰成员。
- static修饰的成员被所有的对象所共享。
- static优先于对象存在,因为static的成员随着类的加载就已经存在了。
- static修饰的成员多了一种调用方式,就可以直接被类名所调用 。 类名.静态成员 。
- static修饰的数据是共享数据,对象中的存储的是特有数据。
- 成员变量和静态变量的区别?
- 两个变量的生命周期不同。
- 成员变量随着对象的创建而存在,随着对象的被回收而释放。
- 静态变量随着类的加载而存在,随着类的消失而消失。
- 调用方式不同。
- 成员变量只能被对象调用。
- 静态变量可以被对象调用,还可以被类名调用。
- 别名不同。
- 成员变量也称为实例变量。
- 静态变量称为类变量。
- 数据存储位置不同。
- 成员变量数据存储在堆内存的对象中,所以也叫对象的特有数据.
- 静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据.
- 1,静态变量。
- 当分析对象中所具备的成员变量的值都是相同的 。
- 这时这个成员就可以被静态修饰。
- 只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
- 如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
- 2,静态函数。
- 函数是否用静态修饰,就参考一点,就是该函数功能是否有访问到对象中的特有数据。
- 简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
- 如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,
- 但是非静态需要被对象调用,而仅创建对象调用非静态的
- 没有访问特有数据的方法,该对象的创建是没有意义。
- static 修饰的变量,可以被各个实例所贡献,被放在了静态存储区
- 静态方法只能访问静态属性
- 静态方法可以通过类名来访问静态方法
- 普通代码块
- public static void main(String[] args){
- {
- int num1 = 4;
- S.o.p (num1);
- }
- int num1 = 5;
- S.o.p(num1);
- }
- 构造代码块:构造代码块先于构造方法执行
- 普通代码块先于构造函数执行
- 静态代码块随着类的加载而执行,只执行一次,比普通代码块快
- 静态代码块先于主方法执行,在类中静态代码块先于构造代码块执行,代码块又先于构造方法执行
- 在类中执行,只执行一次,用静态代码块,如连接数据库
- 在每个实力创建前,预先动作。
- 单例设计模式
- 饿汉式 一加载就创建实例
- class single{
- private static single s = new single();
- private single(){
- }
- public static Sintle getSingle(){
- retunrn a;
- }
- 懒汉式 使用到的时候才创建实例,第一次使用时
- class single{
- public static Single s;
- private single(){
- public static Single getSingle(){
- if(s!==null)
- return s ;
- else{
- s = new Single();
- retur s }
- }
- 继承 extends
- 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承单独的那个类即可。
- 多个类可以称为子类,单独这个类称为父类或者超类。
- 子类可以直接访问父类中的非私有的属性和行为。
- 通过 extends 关键字让类与类之间产生继承关系
- 继承的出现提高了代码的复用性。
- 继承的出现让类与类之间产生了关系,提供了多态的前提
- 要访问父类的私有属性必须用共有的set和get方法
- 子类不能降低父类继承过来的方法的权限
- super: 可以访问父类的构造函数 调用父类的方法
- this.方法名 调用本类中的方法
- 在创建实例中,子类在实例化过程,全自动调用父类的构造方法(无参)
- Java只能单继承和多层继承
- 函数覆盖
- 子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为重
- 写或者复写。
- 父类中的私有方法不可以被覆盖。
- 在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名
- 获取。
- 子类权限一定大于父类权限
- 静态只能覆盖静态方法
- 所有的类都默认继承Object类
- 直接输出类名输出的是 toString 方法 (类名@hashcode)
- 函数toString重写
- public String toString(){
- return “ ”; 修改为“ ”语句
- final
- final可以修饰类,方法,变量。
- final修饰的类不可以被继承。
- final修饰的方法不可以被覆盖。
- final修饰的变量是一个常量。只能被赋值一次。
- 内部类只能访问被final修饰的局部变量。
- 修饰变量,此变量为常量 final a;(最终变量);
- public final String a = “banana”;
- public static final String a = “banana”;
- //static 只创建一个静态存储区
- final 修饰方法后就不能被重写
- public fianl void test(){
- }
- 如果一个类 被final修饰,就不能被继承
- final class fruit{
- }
- 抽象类 abstract
- Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。
- 类是实例的模块
- 抽象类是类的模块
- abstract class Animal{
- public abstract void run(); //写模块,不写方法体
- public abstract void sleep();
- }
- class Person extands Animal{
- //重写方法
- 一个类继承一个抽象类就必须实现抽象类中的所有方法
- 抽象类不能实例化,但是有构造方法
- 抽象类可以有非抽象方法
- 空方法体也是实现
- 接口 interface {}
- 接口就是标准
- 接口里只有常量和抽象方法
- implements 实现
- interface USB {
- //public static final double width = 1.5;
- public width = 1.5;
- }
- //public abstract void getConnetion () ;
- void getConnetion();
- }
- 一个类可以实现多个接口,类可以同时继承抽象类和接口
- 多实现
- 多继承
- 多层继承
- 在面临选择接口还是抽象类时,坚决使用接口,留有余地。
- 适配器类/适配器设计模式
- 抽象类实现接口时,将不要的方法写为空方法体,类再继承抽象
- 多态:
- 父类可以接受字类对象实例
- 父类接受字类,只能访问到父与子共有到方法
- Fruit f = new Apple();
- java中向下转型需向上转型
- instanceof
- 在多态中需向下转型时先判断instanceof,判断某个实例是否属于某个类型
- 设计模式
- 工厂设计模式
- 想用即调用
- 产生实例的方法改变
- 工厂类来产生实例
- 代理设计模式
- 让核心功能与其它功能分离
- 保证其核心功能安全
- 内部类
- 内部类可直接使用外部的私有变量
- 包含关系的时候
- 方法一:先有外部类实例,在new内部类
- 方法二:
- Outer outer = new Outer();
- Outer.Inner in = outer.new Inner();
- in.print();
- 静态内部类
- 普通匿名内部类:new Outer().new Inner().test();
- 静态:new Outer.Inner().test();
- 可以不先创建外部类。直接外部类名.内部类来new
- 静态类访问外部静态变量
- 在方法里被定义类
- 可以调用外部类的变量
- 调用类要在方法里new Inner().innerTest();
- 内部类,如果被定义在函数中,内部类要访问外部类函数的行参,行参要被final修饰
- 匿名内部类(有接口)
- 灵活,用的时候在写
- 一般来实现接口里的方法(无构造方法,匿名=无名)
- new A(){
- public void test(){
- System.out.println(“ok”);
- }}.test();
- 接口里边可以定义内部接口和抽象类
- 抽象类里也可以定义接口和抽象类
- 包装类
- 基本数据类型 包装类
- int Integer
- char Character
- short Short
- long Long
- float Float
- double Double
- boolean Boolean
- byte Byte
- 装箱和拆箱
- 装箱:将基本数据类型变为包装类
- 拆箱:将一个包装类变为基本数据类型
- JDK1.5后自动装箱和拆箱
- 包装类的应用:
- String str1 = “30”;
- String str2 = “30.3”;
- int x = Integer.parseInt(str1); //将字符串变为int型
- float f = Float.parseFloat(str2); //将字符串变为float型
- 异常
- 异常处理不一定是解决问题,也可能是抛出问题
- 异常处理机制 Exception
- try{
- //写可能出现异常的代码
- }catch(Exception e){
- System.out.println(“e”):
- //异常输出的语句
- //getMessage() 获取异常信息,返回字符串
- //toString() 获取异常类名和异常信息,放回字符串
- //printSatckTrace 获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void
- }finaly{
- //这里的代码一定会执行,一般关闭资源的代码放这
- }
- 保证在出现异常处理后,正常执行后程序
- System.out.println(0); //强制退出虚拟机,就不会执行
- 异常处理的原则
- 谁调用谁处理
- throws:用于标识函数暴露出的异常*(用在函数上,后面跟异常类名)
- throw:用于抛出异常对象*(用在函数内,后面更异常对象)
- 自定义异常
- 自定义类继承Exception或者其子类
- 通过构造函数定义异常信息
- class DemoException extends Exception
- {
- DemoException(String message)
- {
- super(message);
- }
- }
- RuntimeException()
- 运行时异常,可以不声明跑出(throws)
- 一个方法被覆盖到时候,抛出时继承应该是相同的异常或子类
- 如果覆盖方法时,不能抛出新的异常,只能是子类
- 包
- 全限定名:包名+类名
- 确保包类名不冲突
- 被访问的包中的类权限必须是public的
- public protected default private
- 同一类 ✓ ✓ ✓ ✓
- 同一包 ✓ ✓ ✓
- 不同包子类 ✓ ✓
- 不同包 ✓
- 父类中受保护的方法可以在不同的包中的字类所访问
- set classpath 设置路径时不能加引号
- set path=%path%;xxx/xx/x %path% 保存原地址
多线程(Thread)
- 继承和实现
- class MyThread extends Thread {
- //需要在线程中运行的代码需要需要写在run方法
- public void run(){
- start 是将线程加到线程组里面
- 线程不能重复开启
- Java程序运行至少两个线程:main 和 垃圾回收线程
- Runnable 可以实现数据共享,实际是多个线程,跑的是一个对象实例
- 在实际开发中一般使用Runnable
- 线程安全问题:
- 数据共享
- 多步操作
- 同步(synchronized)
- 一切对象都可以是锁
- 同步代码块能不能同步,看锁(this)
- 同步函数
- 同步函数的锁就是this
- wati() :失去cpu的执行权,且程序锁
- sleep() :失去cpu的执行权
- StringBuffer() ;
- lastIndexof() ;
- subString() ;
- Process 一个进程
- java.sql.Date dd = new java.sql.Date(new java.util,Date().getTime());
- 数据库时间 java中时间
- java中的时间不能强转为数据库的时间
- Math.random() ;
- (随机数)
- 返回带正号的double值,该值大于等于0.0且小于1.0
- (int)(Math.random() * x)+1 1~x
- 类 Random
- 生成伪随机数
- new Random().newtInt(7)); 0~7(不包含7)
- NumberFormat
- NumberFormat.getInstance()
- 类 DecimalFormat
- ###,###.#####
- 000,000.00000 (没有的位数用0补齐)
- String format1 = “###,###.#####”; //格式字符
- 小数部分不进行分组
- DecimalFormat df = new DecimalFormat(format1);
- sop(df.format(12345.123456)
- 格式字符后: ¥ $ % ‰
- 类 BigInterger 大数
- 对象的克隆
- clone();
- 被克隆的对象必须实现cloneable接口
- 须重写object.clone()方法
- 克隆时要强转Dog d2 = (Dog) d1.clone();
- 强转后需要报异常
- Arrays 类 (数组大工具类)
- 正则表达式
- 转义字符
- 定时调度
- Timer 类
- 观察者设计模式
- 泛型
- 不能使用基本数据类型,使用包装类
- class Person<T> {
- 在类里定义泛型
- 在泛型中,不能用父类接受字类
- 通配符<?> 在泛型中,不知道其数据类型
- 可以限定范围
- <?extengs Integer>只能是Integer字类和自己
- <?super Integer>只能是Integer父类和自己
- 泛型接口 (接口:常量、抽象方法)
- interface A<T>{
- T fun1(); //泛型可以作为函数返回值
- }
- 两种实现:
- 创建实例实现
- 定义时实现
- 泛型方法
- 静态方法不能访问类上定义的泛型
- class Test{
- public <T> T fun2(T aa){
- return aa;
- }
- 泛型数组
- 泛型嵌套
- 集合
- 不限定数量的对象数组
- 两个集合:
- collection map
- hashcode ,equals 判断两实例是否为一个。重写两方法。
- List - ArrayLish 可以重复元素
- 父类接受子类的实例,方法只能实现共有的
- 在开发过程中,一个值的lengt(),size() 随着改变而改变,一般将值提取出来
- Collection - set 不可放入重复的元素
- HashSet
- TreeSet 有许存放
- compareable 实现可以比较
- 让一个类可以实现比较,只需实现comparable的compareTo()方法
- 集合标准输出方式
- 迭代器
- Iterator<Student> it = mylist.iterator();
- while(it.hasNext()){
- S.o.p(it.next()).getName);
- }
- or
- Iterator<Student> it = mylist.iterator();
- while(it.hasNext()){
- student s = it.next();
- S.o.p(s.getName());
- }
- 流
- File
- 字节流
- 输出字节流