javaweb学习总结二(静态导入、自动拆装箱、增强for与可变参数)

一:静态导入
语法:import static 导入类.成员变量|成员方法
那么在代码中可以直接使用变量或者方法,而不需要通过类名.来调用

静态导入:

1 import static java.lang.System.out;

那么在代码中直接调用变量:

1 @Test
2     //测试静态导入
3     public void testStaticImport() {
4         out.println("static import...");
5     }

二:装箱或者拆箱
装箱:将基本数据类型赋值给引用数据类型
拆箱:将引用数据类型赋值给基本数据类型

1 @Test
2     public void testAutoBox() {
3         Integer i = 1; // 自动装箱 Integer i = new Integer(1);
4         int j = i; // 自动拆箱 int j = i.intValue();
5         System.out.println(j);
6         List list = new ArrayList();
7         list.add(1); // 这里的1在编译阶段会自动转换为Integer类型
8         System.out.println(list);
9     }

三:增强for循环

1:增强for循环可以遍历数组或者集合

 1 @Test
 2     // 测试增强for循环
 3     public void testForEnhance() {
 4         // 遍历数组
 5         int[] arr = new int[] { 1, 2, 3 };
 6         for (int i : arr) {
 7             System.out.println(i);
 8         }
 9         // 遍历集合
10         List<String> list = new ArrayList<String>();
11         list.add("java");
12         list.add("php");
13         for (String s : list) {
14             System.out.println(s);
15         }
16     }

2:它只能查询不能修改数组或者集合中的内容,如果需要修改容器中的内容,还是要用传统的for循环。

 1 @Test
 2     // 测试增强for循环
 3     public void testForEnhance() {
 4         // 遍历数组
 5         int[] arr = new int[] { 1, 2, 3 };
 6         for (int i : arr) {
 7             i = 10;
 8         }
 9         System.out.println(Arrays.toString(arr));
10         // 遍历集合
11         List<String> list = new ArrayList<String>();
12         list.add("java");
13         list.add("php");
14         for (String s : list) {
15             s = "c++";
16         }
17         System.out.println(list);
18     }

数组以及集合中的值并没有发生变化。

3:集合只有实现了Iterable,才能够使用增强for循环,因为for循环的底层还是迭代器

 1 @Test
 2     public void testIterator() {
 3         List<String> list = new ArrayList<String>();
 4         list.add("java");
 5         list.add("php");
 6         // 使用迭代器
 7         Iterator<String> it = list.iterator();
 8         while (it.hasNext()) {
 9             String str = it.next();
10             System.out.println(str);
11         }
12         // 使用for循环
13         for (String str : list) {
14             System.out.println(str);
15         }
16     }

4:使用for循环遍历set集合,但是不能遍历map集合,因为map集合没有实现Iterator接口

但是我们可以将map集合转化为set集合

遍历set集合:

 1 @Test
 2     public void testIteratorSet() {
 3         Set<String> set = new HashSet<String>();
 4         set.add("1");
 5         set.add("2");
 6         // 迭代器遍历
 7         Iterator<String> it = set.iterator();
 8         while (it.hasNext()) {
 9             String str = it.next();
10             System.out.println(str);
11         }
12         // for循环遍历
13         for (String str : set) {
14             System.out.println(str);
15         }
16     }

遍历map集合:

a:keyset的方式

 1     @Test
 2     public void testIteratorMap() {
 3         Map<Integer, String> map = new HashMap<Integer, String>();
 4         map.put(1, "orange");
 5         map.put(2, "apple");
 6         map.put(3, "banana");
 7         // 使用迭代器
 8         Set<Integer> set = map.keySet();
 9         Iterator<Integer> it = set.iterator();
10         while (it.hasNext()) {
11             Integer key = it.next();
12             String value = map.get(key);
13             System.out.println(key + "=" + value);
14         }
15         System.out.println("...........");
16         // 使用for循环
17         for (Integer i : map.keySet()) {
18             Integer key = i;
19             String value = map.get(key);
20             System.out.println(key + "=" + value);
21         }
22     }

b:entryset的方式

 1     @Test
 2     public void testIteratorMap2() {
 3         Map<Integer, String> map = new HashMap<Integer, String>();
 4         map.put(1, "orange");
 5         map.put(2, "apple");
 6         map.put(3, "banana");
 7         // 使用迭代器
 8         Set<Entry<Integer, String>> set = map.entrySet();
 9         for (Entry<Integer, String> en : set) {
10             Integer key = en.getKey();
11             String value = en.getValue();
12             System.out.println(key + "=" + value);
13         }
14         System.out.println("................");
15         // 使用增强for循环
16         for (Entry<Integer, String> en : map.entrySet()) {
17             Integer key = en.getKey();
18             String value = en.getValue();
19             System.out.println(key + "=" + value);
20         }
21     }

5:HashMap类底层的排序是hashcode,不是有序的,这时我们可以使用LinkedHashMap类

可以按照我们放入的顺序取出元素。

四:可变参数

方法名(类型 ...变量名称){

方法体;

}

 1 @Test
 2     public void testVariableArgs() {
 3         int sum = getSum(1, 2, 3, 4);
 4         System.out.println("sum=" + sum);
 5     }
 6
 7     public int getSum(int... nums) {
 8         int sum = 0;
 9         for (int i : nums) {
10             sum += i;
11         }
12         return sum;
13     }

可变参数注意点:

我们可以把可变参数看做一个数组:

1 @Test
2     public void testVariableArgs2() {
3         int[] arr = new int[] { 1, 2, 3, 4 };
4         System.out.println(getSum(arr));
5     }

 

时间: 2024-10-11 04:28:52

javaweb学习总结二(静态导入、自动拆装箱、增强for与可变参数)的相关文章

Java5新特性之静态导入、可变参数、增强for循环、自动拆装箱

JDK1.5已经发布很长时间,之所以还拿出来是因为它增加了很多个重要的特性,使用这些特性有助于我们简化开发,编写的代码更加简洁清晰安全,主要有以下几个特性: ?  静态导入 ?  可变参数 ?  增强for循环 ?  自动拆装箱 ? 泛型 ? 枚举 由于泛型.枚举内容比较多,也最重要,之后单拿出来讲.这里先介绍前面四个简单而又实用的小特性. 1. 静态导入 所谓"静态导入"只不过是在普通的import语句中加入关键字static,例如: ?  非静态导入:import java.lan

静态导入方法即自动拆装箱(java)

package example6;import static java.lang.System.out;import static java.util.Arrays.sort;import java.util.Arrays;class quietWay{    /*1.静态导入(了解)     * 可以在代码里面,直接使用静态导入方法,导入静态方法或常量     * import static 包名;     * 比如实现一个计算器,在math类里面     * */    public sta

javaweb学习总结(二十八)——JSTL标签库之核心标签【转】

原文地址:javaweb学习总结(二十八)——JSTL标签库之核心标签 一.JSTL标签库介绍 JSTL标签库的使用是为弥补html标签的不足,规范自定义标签的使用而诞生的.使用JSLT标签的目的就是不希望在jsp页面中出现java逻辑代码 二.JSTL标签库的分类 核心标签(用得最多) 国际化标签(I18N格式化标签) 数据库标签(SQL标签,很少使用) XML标签(几乎不用) JSTL函数(EL函数) 三.核心标签库使用说明 JSTL的核心标签库标签共13个,使用这些标签能够完成JSP页面的

Java自动拆装箱(Autoboxing and unboxing)学习

在学习并发的过程中,用"Boolean bool = true"的自动装箱方式初始化了两个对象锁去锁两块代码,结果运行的时候出现了竞争等待,调试了一下发现两个锁变量指向的是同一个对象,由此可见我对自动拆装箱的机制想的太简单了,查了一下,发现这个机制还挺细节,那就记录一下: 本文主要有以下几个方面: 什么是自动拆装箱 拆装箱的实现 拆装箱发生的场景 关于String 回首望月 尝试的第一篇博客,不当之处,求轻喷! 一. 什么是自动拆箱与装箱 我们都知道,Java定义了8种基本类型和与之对

Java连载78-深入自动拆装箱、Date类和SimpleDateFormat格式化

一.深入自动拆装箱 1.直接举例: public class D78_AutomaticUnpackingAndPacking{ public static void main(String[] args){ Integer i1 = new Integer(10); Integer i2 = new Integer(10); //这里不会自动进行拆箱 System.out.println(i1==i2);//false //比较两个Integer类型的数据是否相等,不能用“==" //Inte

浅谈java中的自动拆装箱

Java在jdk1.5之后推出的一个新特性:自动拆装箱. 该特性不是jvm认可的,而是编译允许 public class Integerdemo03 {     public static void main(String[] args) {         /**          * 编译器在编译下列代码时补充了代码          * Integer n= Integer.valueOf(1);          * 自动装箱          */         int a=100;

进制转换与两个变量的交换方式以及自动拆装箱

一.两个变量的交换方式 1.定义一个中间变量 int a = 1, b = 2; int c = b; b = a; a = c; 2.数据叠加再相减 int a = 1; int b = 2; a = a + b; b = a - b; a = a - b; 3.通过异或^ int a = 1; int b = 2; a = a^b; b = a^b; a = a^b; 二.数据定制转换 System.err.println(Integer.parseInt("1f", 16));/

java基础第九天_多线程、自动拆装箱

1.蜜蜂和熊的生产消费关系,熊在蜂蜜满10斤吃掉.蜜蜂一次生产一斤蜂蜜,且蜜蜂生成一斤蜂蜜花费的时间是10s. 十只蜜蜂和两只熊. 2.取出两个字符串中最大的公共子串. 3.StringBuffer是线程安全的,StringBuilder不是线程安全.单线程访问情况下,性能是否一致? 4.完成8中基本数据类包装类的练习,完成自动拆装箱操作. 1.蜜蜂和熊的生产消费关系,熊在蜂蜜满10斤吃掉.蜜蜂一次生产一斤蜂蜜,且蜜蜂生成一斤蜂蜜花费的时间是10s. 十只蜜蜂和两只熊. /** * 蜜蜂.熊的例

一文读懂什么是Java中的自动拆装箱

基本数据类型 基本类型,或者叫做内置类型,是Java中不同于类(Class)的特殊类型.它们是我们编程中使用最频繁的类型. Java是一种强类型语言,第一次申明变量必须说明数据类型,第一次变量赋值称为变量的初始化. Java基本类型共有八种,基本类型可以分为三类: 字符类型char 布尔类型boolean 整数类型byte.short.int.long 浮点数类型float.double. Java中的数值类型不存在无符号的,它们的取值范围是固定的,不会随着机器硬件环境或者操作系统的改变而改变.