Jdk5以后的新特性:
增强for,静态导入,可变参数,泛型,自动拆装箱...
增强for循环的格式
for(数据的类型 变量名 : 数组或者集合对象名){
输出变量即可!
}
增强for的出现是替代迭代器的,所以在遍历集合或者遍历数组时就可以使用增强for去完成
增强for循环的弊端:如果集合的对象是null,如果再次对集合操作,就会出现异常
格式:
修饰符 返回值类型 方法名(数据类型...变量名){...}
注意:
1)变量名:看成一个数组
2)使用的时候数据类型后面是三个点...
注意:根据具体的需求去完成,一般情况,知道有这个特性就可以了
增强for,静态导入,可变参数,泛型,自动拆装箱...
增强for循环的格式
for(数据的类型 变量名 : 数组或者集合对象名){
输出变量即可!
}
增强for的出现是替代迭代器的,所以在遍历集合或者遍历数组时就可以使用增强for去完成
增强for循环的弊端:如果集合的对象是null,如果再次对集合操作,就会出现异常
对集合进行判断,非空判断解决
public static void main(String[] args) {
//定义一个数组,静态初始化
int[] arr = {11,22,33,44,55} ;
//正常的方式,普通for循环
for(int x = 0 ; x < arr.length ; x ++) {
System.out.println(arr[x]);
}
System.out.println("---------------------");
//增强for循环
for(int a :arr) {
System.out.println(a);
}
//定义一个字符串类型的数组
String[] str = {"hello","world","java","javaee"} ;
//直接增强for
for(String s : str) {
System.out.println(s);
}
System.out.println("**************************");
//创建一个集合
List<String> list = new ArrayList<String>() ;
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//直接增强for
for(String s:list) {
System.out.println(s);
} list = null ;//定义一个空集合，用增强for进行遍历，编译时期不会有错误，但是运行时出现NullPointerException异常， //这是开发者不愿意看到的结果，所以这是增强for的一个弊端，我们可以在代码中增加非空判断
//NullPointerException
if(list !=null) {
for(String s:list) {
System.out.println(s);
}
} //遍历list集合,判断如果有"world"元素,给集合添加一个元素(javaee)
/*for(String s: list) { //使用size()和get(int index)相结合...
//java.util.ConcurrentModificationException :并发修改异常
//增强for的出现就是用来替代迭代器的!
if("world".equals(s)) {
list.add("javaee");
}
}//在用增强for循环来增加元素时，会出现并发修改异常，所以还是使用迭代器增加。
System.out.println("list:"+list);*/
接下来我们学习静态导入，是导入到方法的级别
import static java.lang.Math.abs; //在这里导入方法包，导入到方法的级别
import static java.lang.Math.pow;
public class ImportStaticDemo {
public static void main(String[] args) {
System.out.println(Math.abs(-100));
System.out.println(Math.pow(2,3));
//可以使用带前缀的方式
System.out.println(java.lang.Math.abs(-100));
System.out.println("-------------------------");
//在测试,直接写方法名,前提静态导入
// System.out.println(abs(-100));//我们可以注意到，这里直接使用的是方法名
//本身当前的某个类中的方法名和需要被静态导入的方法名一样,必须加上前缀
System.out.println(java.lang.Math.abs(-100));
System.out.println(pow(2,3));
}
//Date ---->有两个包下 java.util.Date java.sql.Date
public static void abs() {
}
}
我们做一个小练习放松一下
ArrayList集合存储自定义对象并遍历,有几种方式?
Iterator iterator() ;
listIterator listiterator();(先不写)
普通for循环:size()/get(int index)
增强for循环
我们用三种方式对集合存储自定义对象进行遍历
public class Student {
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String[] args) {
//创建ArrayList集合
ArrayList<Student> array = new ArrayList<Student>() ;
//创建学生对象
Student s1 = new Student("张三", 20) ;
Student s2 = new Student("李四", 19) ;
Student s3 = new Student("王五", 22) ;
Student s4 = new Student("赵六", 26) ;
//添加元素
array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;
//方式1:迭代器遍历:Iterator
Iterator<Student> it = array.iterator() ;
while(it.hasNext()) {
Student s = it.next() ;
System.out.println(s.getName()+"----"+s.getAge());
}
System.out.println("-------------------");
//方式2:普通for
for(int x = 0 ; x < array.size() ; x ++) {
Student s = array.get(x) ;
System.out.println(s.getName()+"----"+s.getAge());
}
System.out.println("-------------------");
//方式3:增强for循环
for(Student s : array) {
System.out.println(s.getName()+"----"+s.getAge());
}
}格式:
修饰符 返回值类型 方法名(数据类型...变量名){...}
注意:
1)变量名:看成一个数组
2)使用的时候数据类型后面是三个点...
注意:根据具体的需求去完成,一般情况,知道有这个特性就可以了
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
int result = sum(a,b) ;
System.out.println("result:"+result);
int c = 30 ;
int result2 = sum(a,b,c);
System.out.println("result2:"+result2);
int d = 40 ;
int result3 = sum(a,b,c,d);
System.out.println("result3:"+result3);
//当我们的参数不确定的情况下,就可以使用jdk5一个特性:可变参数
System.out.println(sum(a,b,c,d,50));
}
//定义一个参数不确定的方法,通过可变参数操作
public static int sum(int...a) {
//求和:将a是多个参数的,看成数组
//先定义最终结果变量
int result = 0 ;
//增强for遍历可变参数a
for(int n :a) {
result += n ;
}
return result;
}//result:30
//result2:60
//result3:100
//150我们再做一个小练习，结束这节的学习。
需求
集合的嵌套遍历
有一个Java基础班,里面有很多学生,把一个班级集合:ArrayList<Student>
不止一个Java基础班,这个时候就定义大集合:ArrayList<ArrayList<Student>>
有三个基础班,分别遍历每一个班里面学生信息:(name,age)
public class Student {
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public static void main(String[] args) {
//创建一个大的集合
ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>() ;
//创建第一个班的集合对象
ArrayList<Student> firstArray = new ArrayList<Student>() ;
//创建学生对象
Student s1 = new Student("孙悟空",35) ;
Student s2 = new Student("猪八戒", 29);
Student s3 = new Student("沙僧", 30) ;
//给第一个班添加元素
firstArray.add(s1) ;
firstArray.add(s2) ;
firstArray.add(s3) ;
//将第一个集合添加到大集合中
bigArrayList.add(firstArray) ;
//创建第二个班集合对象
ArrayList<Student> secondArray = new ArrayList<Student>() ;
Student s11 = new Student("宋江",38) ;
Student s22 = new Student("鲁智深", 29);
Student s33 = new Student("武松", 30) ;
secondArray.add(s11) ;
secondArray.add(s22) ;
secondArray.add(s33) ;
//添加到大集合
bigArrayList.add(secondArray) ;
//创建第三个集合对象
ArrayList<Student> thirdArray = new ArrayList<Student>() ;
Student s111 = new Student("高圆圆",38) ;
Student s222 = new Student("唐嫣", 29);
Student s333 = new Student("刘若英", 30) ;
thirdArray.add(s111) ;
thirdArray.add(s222) ;
thirdArray.add(s333) ;
//添加到集合
bigArrayList.add(thirdArray) ;
//增强for遍历:大集合
for(ArrayList<Student> array: bigArrayList) {
for(Student s:array) {
System.out.println(s.getName()+"---"+s.getAge());
}
}
} //孙悟空---35
//猪八戒---29
//沙僧---30
//宋江---38
//鲁智深---29
//武松---30
//高圆圆---38
//唐嫣---29
//刘若英---30
扫一扫
978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
