Java第四周学习总结
2021/7/31 12:36:31
本文主要是介绍Java第四周学习总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
目录
一、内部类
1.1、局部内部类
1.2、匿名内部类
二、方法的形式参数为引用类型
2.1、方法的形式参数为——接口
2.2、方法的形式参数为——抽象类
三、方法的返回值类型为引用类型
3.1、方法的返回值类型为——接口
3.2、方法的返回值类型为——抽象类
四、常用类及常用方法
4.1、Object类以及常用方法
4.2、String类以及常用方法
4.2.1、String类的常用方法：
4.2.2、String构造方法
4.2.3、String与字符数组转换
4.3、StringBuffer、StringBuilder类及常用方法
4.3.1、StringBuffer类常用方法
4.3.2、StringBuffer和数组的区别
4.3.3、StringBuffer,StringBuilder的区别
4.4、Integer类及常用方法
4.5、Charcater类及常用方法
4.6、Calendar日历类及常用方法
4.7、Date时间类及常用方法
4.7.1、SimpleDateFormat类
4.8、Math类及常用方法
4.9、Random类及常用方法
4.10、BigDecimal类及常用方法
五、集合
5.1、数组和集合区别
5.2、Collection 接口
5.2.1、Colleation接口的常用方法
5.2.2、迭代器——Iterator接口
5.2.3、泛型
5.3、List接口
5.3.1、List接口常用的方法
5.4、增强for循环--foreach
5.5、List接口子实现类一--Vector
一、内部类
1.1、局部内部类
局部内部类的位置，在外部类的成员方法中定义的类。
访问方式：
局部内部类可以访问外部类的成员变量，包括私有属性变量。
在外部类的局部位置，访问内部类的成员方法，创建当前局部内部类对象来访问。
特别的：局部内部类访问局部变量时，在JDK7环境下，该变量必须显示加入final修饰，在JDK8中jvm优化后，默认加入final，无需显示编写。
具体原因：
因为局部变量是随着方法调用而存在，随着方法调用结束而消失。但是当外部类对象调用method方法时，此时num进入栈内存，在局部位置创建了局部内部类对象，局部内部类对象调用它的成员方法访问该变量num，当方法method方法结束之后，内部类对象不会立即消失。它里面的成员方法在访问局部变量局部变量必须变成常量，常驻内存,否则如果当前变量消失了，局部内部类的成员依然在访问，就会出现冲突。
//定义一个外部类
class Outer{
//成员方法
public void method(){
int num = 100 ;
//局部位置:局部内部类
class Inner{
//局部内部类的一个成员方法
public void show(){
System.out.println(num);
}
}
//创建局部内部类对象
Inner inner = new Inner() ;
inner.show() ;
}
}
//测试类
public class OuterDemo {
public static void main(String[] args) {
//访问方式:直接创建外部类类对象
//调用的成员方法
Outer outer = new Outer() ;
outer.method();
}
}
/*
结果
100
*/
1.2、匿名内部类
匿名内部类：一般是在局部位置使用。本质是：继承该类或者接口的子实现类对象
格式：
new 类名（可以是抽象类，可以是具体类，或者是接口名）（）{
//重新方法
};
//定义接口
interface Inter{
//接口的方法
void show() ;
void show2() ;
}
//外部类
class Outer{
//定义一个成员方法
public void method(){
Inter i = new Inter(){
@Override
public void show() {
System.out.println("show Inter...");
}
@Override
public void show2() {
System.out.println("show2 Inter...");
}
};
i.show();
i.show2();
}
}
//测试类
public class OuterDemo {
public static void main(String[] args) {
//创建Outer3类对象
Outer outer = new Outer() ;
outer.method();
}
}
二、方法的形式参数为引用类型
2.1、方法的形式参数为——接口
当方法的形式参数为接口时，其实际传递的是接口的子实现类对象。
表现形式有两种：
方式一：定义接口的子实现类，并创建对象
方式二：使用接口的匿名内部类
//定义一个接口
interface Mary{
void mary() ;
}
//定义一个LoveDemo类
class LoveDemo{
//形式参数是一个接口
public void funciton(Mary mary){
mary.mary();
}
}
//定义一个子类实现类，实现接口
class You implements Mary{
@Override
public void mary() {
System.out.println("要结婚了,很开心...");
}
}
//测试类
public class LoveTest {
public static void main(String[] args) {
//方式1:需要调用LoveDemo类中的function方法
LoveDemo loveDemo = new LoveDemo() ;
//接口多态
Mary mary = new You() ;
loveDemo.funciton(mary);
System.out.println("----------------------------------------");
//方式2:接口的匿名内部类
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
ld.funciton(new Mary() {
@Override
public void mary() {
System.out.println("要结婚了,很开心...");
}
});
}
}
2.2、方法的形式参数为——抽象类
方法的形式参数如果是一个抽象类，那么实际传递的是抽象类的子类。与接口表现形式类似，此处不在做案例演示。
表现形式有两种（类似于接口）：
方式一：定义子类继承抽象类，创建子类对象
方式二：直接使用抽象类的匿名内部类
/**
例题：
看程序,写结果
要求:需要在控制台分别打印30,20,10
*/
class Outer{
int num = 10 ;
//成员内部类
class Inner{
int num = 20 ;
public void show(){
int num = 30;
//补全代码
System.out.println(num);
System.out.println(this.num);//this限定 :this.变量名:当前类的成员变量
// System.out.println(new Outer().num) ; //方式1:new Outer().num
System.out.println(Outer.this.num) ; //方式2:外部类的this限定
}
}
}
public class OuterTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner() ;
oi.show();
}
}
三、方法的返回值类型为引用类型
3.1、方法的返回值类型为——接口
方法的返回值是接口类型,需要返回的当前接口的子实现类对象。
表现形式有两种：
方式一：定义接口的子实现类，并创建对象
方式二：使用接口的匿名内部类
//定义接口
interface Love{
void love() ;
}
class LoveDemo{
public Love function(){
return new Love(){
@Override
public void love() {
System.out.println("爱Java,爱学习...");
}
} ;
}
}
//定义接口的子实现类
class Student implements Love{
@Override
public void love() {
System.out.println("爱Java,爱学习...");
}
}
//测试类
public class LoveTest {
public static void main(String[] args) {
//要访问LoveDemo类中的function方法
LoveDemo ld = new LoveDemo() ;
Love love = ld.function();//Love love = new Student() ;
love.love();
System.out.println("------------------");
//方式2:接口匿名内部类的方式
LoveDemo ld2 = new LoveDemo() ;
Love l = ld2.function();
l.love();
}
}
3.2、方法的返回值类型为——抽象类
方法的返回值是抽象类，需要返回的当前抽象类的子类对象。
表现形式有两种：
方式一：定义抽象类的继承子类，并创建对象
方式二：使用抽象类的匿名内部类
具体表现形式与接口类似，此处不做演示。
四、常用类及常用方法
4.1、Object类以及常用方法
在java.lang.Object，Object是类结构层次的根类（父类、超类），所有的类都默认继承自Object子类。所有对象（包括数组）都实现这个类的方法。
常用的方法：
1、public final Class getClass()：表示正在运行的类 (就是字节码文件对象)，表示此对象运行时类的 class 对象。
2、protected Object clone()：创建并返回此对象的一个副本。
3、public int hashCode()：返回该对象的哈希码值。
4、public String toString()：返回该对象的字符串表示形式。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
//举例说明toString方法
//定义一个Student类
public class Student{//默认继承Object
//成员属性/成员方法
String name ;
int age ;
//无参构造方法以及有参构造方法
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写toString方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';//描述学生对象的成员信息表达式
}
}
//定义测试类
public class ObjectDemo {
public static void main(String[] args) {
//通过有参构造方法创建一个学生对象
Student s = new Student("高圆圆",42) ;
//直接输出对象名称，当没有重写toString方法时，会默认调用它的父类:Object的toString方法
System.out.println(s);//输出结果：com.qf.object_06.Student@1540e19d
System.out.println("-----------------------------------");
//重写toString方法后，再调用toString方法
System.out.println(s.toString());//结果：Student{name='高圆圆', age=42}
}
}
5、public boolean equals(Object obj)：obj - 要与之比较的引用对象，如果此对象与 obj 参数相同，则返回 true；否则返回 false。
注意：后面此方法在不同的类/方法中会被重写，当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
//举例：public boolean equals(Object obj)
//定义一个具体Student类
import java.util.Objects;
public class Student {
//定义成员变量：姓名、年龄
String name ;
int age ;
//无参、有参构造
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写Object类的toString
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重写了equals和code方法
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + age;
return result;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name.equals(student.name);
}
}
//定义测试类：
public class ObjectDemo {
public static void main(String[] args) {
int a = 10 ;
int b = 15 ;
System.out.println(a==b);//结果：false，具体原因分析看下文
System.out.println("--------------------------------------------");//区分
Student s1 = new Student("文章",35) ;
System.out.println(s1);/*结果：Student{name='文章', age=35}。在Student类中重写了toString方法*/
Student s2 = new Student("文章",35) ;
System.out.println(s2);//s1同理。
System.out.println(s1 == s2);//false，具体原因分析看下文
System.out.println("--------------------------------------");
System.out.println(s1.equals(s2));
//没有重写之前:执行的是Object类的equals()，结果为：false
//重写之后,就比较的是对象的成员信息是否一致!结果为：true
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println("文章".hashCode());
System.out.println("---------------------------------------------");
String str1 = "hello" ;
String str2 = "hello" ;
System.out.println(str1.equals(str2));
String str3 = "world" ;
String str4 = new String("world") ;
System.out.println(str3.equals(str4));
}
}
案例分析：
"==" 和equals都有比较的意思，两者间的区别：
== ：
连接基本数据类型时：比较的是数据值是否相同。
连接引用数据类型时：比较的是对象的地址值。
equals：
如果使用Object默认的方法，默认比较的还是两个对象的的地址值是否相同。
当equals和hashCode方法被重写之后，那么比较的就是两个对象的内容是否相同。
4.2、String类以及常用方法
String修饰的变量，字符串类型（特殊的引用数据类型），字符串是一个final类（常量），一旦被赋值之后其值（地址值）不能被更改。
String 变量名 = "abcd123"; ""双引号内的是String的实例。
4.2.1、String类的常用方法：
int length()：获取字符串长度。
char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索 。注：indexOf和lastIndexOf方法如果未找到都是返回-1
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement) ： 使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement) ：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
4.2.2、String构造方法
public String()：空参构造:空字符序列
public String(byte[] bytes)：将一个字节数组构造成一个字符串,使用平台默认的字符集(utf-8:一个中文对应三个字节) 解码。
public String(byte[] bytes,字符集)：使用指定的字符集,将字节数组构造成一个字符串
public String(byte[] bytes,int offset,int length)：将指定的部分字节数组转换成字符串
参数1:字节数组对象,参数2:指定的角标值 参数3:指定长度
public String(char[] value)：将字符数组构造成一字符串
public String(char[] value,int offset,int count)：将部分字符数组转换成字符串
public String(String original)：构造一个字符串,参数为字符串常量
4.2.3、String与字符数组转换
字符数组——>字符串 String 类的构造器：String(char[]) 和 String(char[]，int offset，int length) 字符串——>字符数组 public char[] toCharArray()： 将字符串中的全部字符存放在一个字符数组 中的方法。 public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法。4.3、StringBuffer、StringBuilder类及常用方法
StringBuffer：java.lang.StringBuffer代表可变的字符序列，字符串缓冲区，线程安全的类 (执行效率低)
StringBuilder：和StringBuffer具有相互兼容的API,它是线程不安全的类，不同步，执行效率高。
StringBuffer的构造方法:
public StringBuffer() :空参构造,创建一个空字符序列的字符串缓冲去
public StringBuffer(int capacity):构造一个字符串缓冲区对象,指定容量大小
public StringBuffer(String str):指定字符序列，长度加上初始容量16(总容量)
4.3.1、StringBuffer类常用方法
获取功能:
public int length():获取字符数(长度)
public int capacity():获取字符串缓冲区容量
添加功能：
StringBuffer append(任何类型) ：将内容追加到字符串缓冲区中 (在字符串缓冲区的最后一个字符序列的末尾追加)返回值是字符串缓冲区本身。
public StringBuffer insert(int offset,String str):插入:在指定位置处插入指定的内容。
删除功能：
public StringBuffer deleteCharAt(int index)：删除指定索引处的缓冲区字符序列,返回字符串缓冲区本身。
public StringBuffer delete(int start,int end):删除从指定位置到指定位置结束的字符序列(包含end-1处的字符),返回字符串缓冲区本身 [start,end-1]。
字符串反转功能（特有功能）：
public StringBuffer reverse(),反转之后,返回的是字符串缓冲区本身。
截取功能：
public String substring(int start):从指定位置开始,默认截取到末尾,返回值是新的字符串
public String substring(int start,int end):从指定位置开始到指定end-1结束进行截取,返回的新的字符串
替换功能：
public StringBuffer replace(int start, 起始索引
int end, 结束索引(end-1)
String str) 替换的内容
4.3.2、StringBuffer和数组的区别
数组：只能存储同一种数据类型容器，数组可以存储基本类型,也可以存储引用类型，长度是固定的。
StringBuffer：支持可变的字符序列，里面存储可以存储任意类型的元素
4.3.3、StringBuffer,StringBuilder的区别
共同点:
两个都都是字符串缓冲区,支持可变的字符序列!
不同点:
StringBuffer:线程安全的类---->同步的(多线程:同步锁:源码几乎所有的方法都是同步方法 synchronized)，执行效率低
StringBuilder:线程不安全的类---->不同步----->执行效率高
单线程程序中,只考虑执行效率不考虑安全,所以StringBuilder类用作StringBuffer的简易替换
多线程环境中,要考虑安全问题只能使用StringBuffer,
线程安全的类:StringBuffer,Vector(List接口的子类)
和String的区别：
String：字符串是一个常量，一旦被赋值，其值不能更改，作为形式参数属于特殊的引用类型，形式参数的改变不会实际参数。
4.4、Integer类及常用方法
int类型的引用类型，包含int类型的原始数据值。
当基本数据类型和String类型之间进行转换时，需要中间“桥梁”，那就是基本数类型的包装类。
构造方法：
Integer(int value):可以将int类型保存为Integer类型
常用方法：
public static String toBinaryString(int i):将整数---->二进制 的字符串
public static String toOctalString(int i):将整数---->八进制的字符串
public static String toHexString(int i):将整数---->十六进制数据
public static final int MAX_VALUE:int的最大值
public static final int MIN_VALUE:int的最小值
4.5、Charcater类及常用方法
Charcater :char类型的包装类类型。
构造方法：
public Character(char value)
常用方法：
public static boolean isUpperCase(char ch):判断当前字符是否大写字母字符
public static boolean isLowerCAse(char ch):是否为小写字母字符
public static boolean isDigit(char ch):是否为数字字符
public static char toLowerCase(char ch):将字符转换成小写
public static char toUpperCase(char ch):将字符转换成大写
4.6、Calendar日历类及常用方法
Calendar是一个抽象基类，提供一些诸如获取年、月、日等等字段值，主用用于完成日期字段之间相互操作的功能。
Calendar实例的方法：
public static Calendar getInstance()；
成员方法：
public int get(int field):根据给定日历字段----获取日历字段的值(系统的日历)public
public final Date getTime() ：返回一个表示此 Calendar 时间值
abstract void add(int field,int amount):给指定的日历字段,添加或者减去时间偏移量
参数1:日历字段
参数2:偏移量
public void set(int field,int value)：将给定的日历字段设置为给定值。
public final void setTime(Date date)：使用给定的 Date 设置此 Calendar 的时间。
4.7、Date时间类及常用方法
java.util.Date:表示特定瞬间,精确到毫秒。
构造方法：
public Date():当前系统时间格式
public Date(long date):参数为 时间毫秒值---->Date对象
常用方法：
getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
toString():把此 Date 对象转换为以下形式的 String： dow mon ddhh:mm:ss zzz yyyy 其中：dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准
4.7.1、SimpleDateFormat类
DateForamt:抽象类----提供具体的日期/格式化的子类:SimpleDateFormat
格式化：日期——文本、解析：文本——日期
格式化：
SimpleDateFormat() ：默认的模式和语言环境创建对象
public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
public String format(Date date)：方法格式化对象
注：
"yyyy"-------年
"MM"-------月
"dd"-------日
"HH"-------小时数
"mm"-------分钟数
"ss"-------秒数
解析：
public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。
如果解析的字符串的格式和 public SimpleDateFormat(String pattern)的参数模式不匹配的话,就会出现解析异常
4.8、Math类及常用方法
java.lang.Math提供了一系列静态方法用于科学计算。Math类中的功能都是静态的,里面构造方法私有化。 public static int abs(int a):绝对值方法
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static int max(int a,int b):获取最大值
public static int min(int a,int b):获取最小值
public static double pow(double a,double b):a的b次幂
public static double random():[0.0,1.0):随机数
public static long round(double a):四舍五入
public static double sqrt(double a):开平方根
4.9、Random类及常用方法
它有两种构造方法：
(1) public Random(): 产生一个随机生成器对象,通过成员方法随机数每次都不同。
(2) public Random(long seed): 参数为long类型的值(随机数流:种子),每次通过成员方法获取随机数产生的随机数相同的。
获取随机数的成员方法：
（1）public int nextInt()：获取的值的范围是int类型的取值范围(-2的31次方到2的31次方-1)；
（2）public int nextInt(int n)：获取的0-n之间的数据[0,n) (不包含n)
4.10、BigDecimal类及常用方法
Java提供的类: BigDecimal，小数要进行精确计算-还可以计算的同时保留小数点后的有效位数
构造方法：
public BigDecimal(String value):数字字符串
成员方法：
public BigDecimal add(BigDecimal augend)加
public BigDecimal subtract(BigDecimal subtrahend)减
public BigDecimal multiply(BigDecimal multiplicand)乘
public BigDecimal divide(BigDecimal divisor):除
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
参数1:商
参数2:小数点后保留的有效位数
参数3:舍入模式 :四舍五入
五、集合
集合：
面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
5.1、数组和集合区别
（1）长度区别：
数组：数组在初始化后，长度就固定了。
集合：集合的长度是可变的。
（2）存储数据类型的区别
数组：数组在在声明时就确定了数据类型，所以数组中存储的数据都是同一类型。可以存储基本数据类型，也可以存储引用数据类型。
集合：加入泛型后，只能存储该引用类型，没有加入泛型，可以存储任何引用类型。
5.2、Collection 接口
Collection 接口的子接口：
LIst：元素有序、可重复的集合。ArrayList,LinkedList,Vector
Set：元素无序、不可重复的集合
5.2.1、Colleation接口的常用方法
boolean add(Object e):添加元素
oolean addAll(Collection c):添加一个集合中的所有元素
void clear() 暴力删除(将集合的素有元素全部删除)
boolean remove(Object o):从集合中删除指定的元素
int size()获取集合的元素数
boolean isEmpty():判断集合是否为空,为空元素,则返回true
boolean contains(Object o):判断集合中是否包含指定元素,包含则返回true
boolean containsAll(Collection c):包含一个集合中的所有元素
boolean removeAll(Collection c):删除集合中的所有元素
boolean retainAll(Collection c):A集合对B集合求交集
Object[] toArray():将集合转换成了对象数组
5.2.2、迭代器——Iterator接口
Collection的迭代器--iterator()：集合的专有遍历方式
其遍历功能主要是依据这两个方法：
boolean hasNext():判断迭代器中是否存在下一个元素
Object next(): 获取下一个可以遍历的元素
5.2.3、泛型
模拟数组创建的时候,就已经明确了数据类型
声明格式：
集合类型<引用数据类型> 集合对象名 = new 子实现类<引用数据类型>() ;
泛型的好处:
1)将运行时期异常提前了编译时期
2)避免了强制类型转换
3)提高了程序安全性
5.3、List接口
List接口继承Collection
List集合特点:
有序(存储元素和取出元素一致)
允许元素重复
5.3.1、List接口常用的方法
void add(int index,Object element):在指定的索引处插入元素
Object get(int index):获取指定位置处的元素
Object remove(int index):删除指定位置处的元素
Object set(int index,E element):修改指定位置处的元素(替换)
5.4、增强for循环--foreach
JDK5以后提供了增强for循环，替代集合中迭代器去遍历集合使用的(优先在集合中使用)。
格式：
for(存储的引用数据类型 变量名: 集合/数组对象){ //集合使用居多,数组一般都是使用普通for
使用变量名即可
}
注意事项:
当前集合对象不能为空 null :foreach语句:增强for它本身就是获取迭代器了,就会出现空指针异常。
5.5、List接口子实现类一--Vector
大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
Vector集合特有功能：
public void addElement(Object obj):在vector对象的末尾添加元素
public boolean removeElement(Object obj):删除元素
public Object elementAt(int index):获取指定位置的元素
public Enumeration<E> elements() :Vector集合的专有遍历方式
boolean hasMoreElements():判断是否有更多的元素可以迭代
Object nextElement() 获取元素
这篇关于Java第四周学习总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-09-21订单系统资料入门教程：轻松管理你的订单
- 2024-09-21Java部署资料：新手入门教程
- 2024-09-21Java部署资料：新手入门教程
- 2024-09-21Java订单系统资料：新手入门教程与实战指南
- 2024-09-21Java管理系统资料入门教程
- 2024-09-21从零开始学习Java监控系统资料
- 2024-09-21Java就业项目资料：新手入门的必备教程
- 2024-09-21Java全端资料：初学者指南
- 2024-09-21Java全栈资料入门教程及资源汇总
- 2024-09-21Java日志系统资料入门教程
