package java静态导入;
import static java.lang.System.out; //用的不多,可阅读性下降
import org.junit.Test;
public class Demo {
@Test
public void test(){
out.print("静态导入测试");
}
}package 可变参数;
import org.junit.Test;
public class Demo {
@Test
public void testSum(){
System.out.println(sum(1,2,3,4,5,6));
System.out.println(sum(1,2));
}
//可变参数，就把参数看成数组,参数也可以传送一个数组
public int sum(int ...nums){
int sum = 0;
for(int num : nums){
sum = sum +num;
}
return sum;
}
@Test
public void testSum2(){
sum2(1,2,3,4);
}
//可变参数需要注意的问题 public void sum2(int ...nums , int x )这样写有错，可变参数必须放在最后一个参数
public void sum2(int x ,int ...nums){
System.out.println("X:"+x);
}
}package 增强for循环;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.junit.Test;
//能否使用增强for循环的关键是：该类是否继承了util接口
public class Demo {
@Test
public void test() {
int[] arr = { 1, 2, 3, 4 };
for (int num : arr) {
System.out.println(num);
}
}
// java.util.List 使用增强for循环
@Test
public void test2() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for (Object num : list) {
int i = (Integer) num;
System.out.println(i);
}
}
@Test
public void test3() {
Map map = new HashMap();
map.put("1", "AAA");
map.put("2", "bbb");
map.put("3", "ccc");
// 传统方式1
Set set = map.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
String key = it.next().toString();
String value = map.get(key).toString();
System.out.println("key:"+key+" value:"+value);
}
}
@Test
public void test4() {
Map map = new HashMap();
map.put("1", "AAA");
map.put("2", "bbb");
map.put("3", "ccc");
// 传统方式2
Set set = map.entrySet();
Iterator it = set.iterator();
while(it.hasNext()){
//entry 为map中的辅助类：为key-value键值对
Map.Entry entry = (Map.Entry) it.next();
System.out.println("key:"+entry.getKey()+" value:"+ entry.getValue());
}
}
// java.util.Map使用增强for循环
@Test
public void test5() {
Map map = new HashMap();
map.put("1", "AAA");
map.put("2", "bbb");
map.put("3", "ccc");
// 增强for循环
for(Object obj : map.keySet()){
String key = (String ) obj;
String value = (String) map.get(key);
System.out.println("key:"+key+" value:"+value);
}
}
// java.util.Map使用增强for循环2
@Test
public void test6() {
Map map = new HashMap();
map.put("1", "AAA");
map.put("2", "bbb");
map.put("3", "ccc");
//增强for循环
for(Object obj : map.entrySet()){
Map.Entry entry = (Entry) obj;
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:"+key+" value:"+value);
}
}
//使用增强for循环需要注意的几个问题
@Test
public void test7() {
int[] arr = {1,2,3};
for(int i : arr){
//表示int i = arr[X] 只是把数组中的值取出来暂存在中，并不会改变arr[x]的值，改变的是i的值
//List或者其他集合类型也是一样的，不会改变集合中的内容
i =10;
}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}package 自动装箱和拆箱;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.junit.Test;
//自动装箱和拆箱：基本数据类型和对象数据类型的自动转换
public class Demo {
@Test
public void test(){
Integer i = 1; //后台自动装箱，执行 -> Integer i = new Integer(1);
//典型应用
List list = new ArrayList<Integer>(); //集合中只能存放对象 new ArrayList<int>()会报错
list.add(1); //list.add(new Integer(1));
list.add(new Integer(2));
list.add(3);
list.add(4);
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next()); //拆箱
}
}
}package 枚举;
import org.junit.Test;
public class Demo {
@Test
public void test() {
print(Grade.A);
}
public void print(Grade g) {
String value = g.getValue();
System.out.println(value);
}
}
/*
* class Grade{
* private Grade(){}
* public static final Grade A = new Grade();
* public static final Grade B = new Grade();
* public static final Grade C = new Grade();
* public static final Grade D = new Grade();
* public static final Grade E = new Grade(); }
*/
//枚举类型中的元素是枚举类型的对象实例，本质上也是调用了枚举类型（特殊的类）的构造方法（不带括号则调用无参的构造方法）
enum Grade {// 此处枚举类型和以上注释代码完全等效 A:100-90 B:89-80 C:79 - 70 D: 69-60 E:59-0
// A, B, C, D, E; 此处的5个对象是调用本类对象的默认无参的构造函数得到的
A("100-90"), B("89-80"), C("79-70"), D("69-60"), E("59-0"); // 调用有参构造函数
private String value; // 封装每个对象对应的分数
private Grade(String value) { // 覆盖了无参构造函数
this.value = value;
}
public String getValue() {
return this.value;
}
}<span style="color:#330099;">
</span>package 枚举;
import org.junit.Test;
//带抽象方法的枚举
public class Demo带抽象方法的枚举类型 {
@Test
public void test() {
print(Grade2.A);
}
public void print(Grade2 g) {
System.out.println(g.getLocalValue());
}
}
enum Grade2 { //枚举类型其实就是特殊的类
A("100-90") { //每一个枚举值代表了枚举类型中的一个对象实例
public String getLocalValue() { // 内部类实现了Grade2的getLocalValue的抽象方法
return "优";
}
}, //当枚举类型中只有一个值的时候，其相当于单态设计模式
B("89-80") {
public String getLocalValue() {
return "良";
}
},
C("79-70") {
public String getLocalValue() {
return "中";
}
},
D("69-60") {
public String getLocalValue() {
return "及格";
}
},
E("59-0") {
public String getLocalValue() {
return "不及格";
}
};
private String value;
private Grade2(String value) { //枚举类的构造函数必须是私有的,因为枚举类型的实例化只能出现在枚举类的内部
this.value = value;
}
public abstract String getLocalValue(); // 抽象方法(枚举类也可以实现接口或继承抽象类的)
}
//单态设计模式的最简单实现
enum Grade3{ //class
A; //object
}
package 枚举;
import org.junit.Test;
public class Demo常用的枚举方法 {
@Test
public void Test(){
String a = "A";
System.out.println("名称"+Example.A.name());
//存在为String类型的a时，不会报错，否则会抛出异常，常常用来判断表单提交的数据中是否为某个枚举类型中的值
System.out.println("存在该值"+Example.valueOf(a)); //用的比较多
System.out.println("在声明的枚举类型中的位置:"+Example.B.ordinal());//下标从0开始计算
//遍历枚举类型
Example[] exs = Example.values();
for(Example value : exs)
System.out.print(value+" ");
}
}
enum Example{
A,B,C,D,E;
}
原文地址：http://blog.csdn.net/u010218226/article/details/42648701
