1，静态导入
import static java.lang.Math.*;
//静态导入的是静态方法和静态类，或者是静态成员变量
class StaticImport
{
public static void main(String[] args)
{
int a=Math.max(10,20);
int b=Math.min(10,20);
System.out.println(a);
System.out.println(b);
}
}
2，装箱和拆箱
//装箱和拆箱
//值类型转换为引用类型---装箱
//引用类型转换为值类型---拆箱
class BoxAndUnBox
{
public static void main(String[] args)
{
//5.0之后才可以这样写
// Integer i=new Integer(0);
// int j=i; //将值类型转换为封装类型，即装箱
//4.0版本 需要进行封箱，和拆箱
Integer i=new Integer(10);
int j=i.intValue();
System.out.println(j);
Double dou=new Double(20.0);
double d=dou.doubleValue();
System.out.println(d);
//反之
int int1=1;
Integer int2=new Integer(int1);
System.out.println(int2);
System.out.println(i+"...."+j);
int x= 0;
Integer y=x;
System.out.println(x+"..."+y);
/*
*0....0
*0...0
//在基本数据类型中，会出现int-- short--long--float--double之间的转换
//例如：
*/
int z=10;
print(10); //此时调用 print(int i)，若将 print(int i)注释掉，则会调用 print(short i)。。。。一次类推
}
public static void print(int i)
{
System.out.println(i);
}
public static void print(short i)
{
System.out.println(i);
}
public static void print(long i)
{
System.out.println(i);
}
public static void print(float i)
{
System.out.println(i);
}
public static void print(double i)
{
System.out.println(i);
}
}
3，可变类型
class Variable
{
public static void main(String[] args)
{
Integer[] numsInteger={1,2,3,4,5,6,7};
print(numsInteger);
/*
1
2
3
4
5
6
7
This is print[]
*/
//int[] numsInt={1,2,3,4,5,6,7};
//print(numsInt);//这样写将报错
/*
需要: Integer[]
找到: int[]
原因: 无法通过方法调用转换将实际参数int[]转换为Integer[]
*/
printVar(1,2,3,4,5,6);//调用可变类型参数方法
printVar(numsInteger);
}
public static void print(Integer[] num)
{
for (int i=0;i<num.length ; i++)
{
System.out.println(num[i]);
}
System.out.println("This is print[]");
}
public static void printVar(Integer... num) //这里使用可变类型，可变类型默认为数组，
{
for (int i=0;i<num.length ; i++)
{
System.out.println(num[i]);
}
System.out.println("This is printVar[]");
}
//public static void printVar(Integer[] num)
//此方法不能与可变参数 public static void printVar(Integer... num) 同时存在，因为可变参数最终被当做数组使用
//实际参数是组数，数组将被打散最终以printVar（1,2，3,4,5,6,7）进行传入
//可变参数只能放在方法参数列表的最后一位：一个方法只能有一个可变参数
// public static void printVar(Integer... num,int a)错误
// public static void printVar(Integer... num，String... str) 错误
}
4，泛型
package cn.itcast.base;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
public class GenericTest {
public static void main(String[] args) {
/*
* 格式：类型<类型[,类型...]>
* * 泛型使用必须前后相同
* * 泛型是在编译前进行类型约束，在字节码文件中不存在泛型信息
*/
List<String> list = new ArrayList<String>();
list.add("abc");
// list.add(123);
Map map = new HashMap();
map.put(123, 123);
//没有泛型的map 的遍历
Set s = map.entrySet();
Iterator ite = s.iterator();
while(ite.hasNext()){
Map.Entry entry = (Entry) ite.next();
Integer key = (Integer) entry.getKey();
Integer value = (Integer) entry.getValue();
System.out.println("*** " + key + ":" + value);
}
Map<String,Integer> map2 = new HashMap<String, Integer>();
map2.put("123", 456);
map2.put("abc", 789);
//遍历map [key,value][key,value]
// map2.keySet() 获得所有的键值 key
Set<Map.Entry<String,Integer>> set = map2.entrySet(); //获得每一组 Entry(key,value)
//迭代器
Iterator<Entry<String,Integer>> it = set.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> entry = it.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + ":" + value);
}
}
/*
* 不能同时存在
* public void demo(List<String> list){
}
public void demo(List<Integer> list){
}*/
}
5,foreach
package cn.itcast.base;
import java.util.ArrayList;
import java.util.List;
public class ForEachTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
//list.add(123);
//遍历list
for(int i = 0 ; i < list.size(); i ++){
String obj = list.get(i);
System.out.println(obj);
}
for(String s:list){
System.out.println("##" + s);
}
//没有泛型
List l = new ArrayList();
l.add("abc");
l.add(123);
for(Object o :l){
System.out.println("---" + o);
}
String[] str = {"abc","edc"};
for(String s:str){
System.out.println("string " + s);
}
/* foreach
* for(类型 变量名 : 集合(Iterable)|数组){}
*
* * 需要实现Iterable接口的所有的集合。只要能够迭代的所有的集合
*/
}
}
package cn.itcast.base;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ForEachTestDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("abcd");
list.add("asf");
list.add("ceg");
list.add("daf");
list.add("dfs");
//迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
if(str.contains("a")){
//list.remove(str); //java.util.ConcurrentModificationException
it.remove();
}
}
System.out.println(list);
}
public void demo3(){
//java.util.Arrays.ArrayList
List<String> list = Arrays.asList("abc","bcd", "asf", "ceg", "daf", "dfs");
for(int i = 0 ; i < list.size() ; i ++){
String str = list.get(i);
if(str.contains("a")){
//java.lang.UnsupportedOperationException
list.remove(i);
}
}
System.out.println(list);
}
public void demo2(){
//不能删除
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("abcd");
list.add("asf");
list.add("ceg");
list.add("daf");
list.add("dfs");
//java.util.ConcurrentModificationException
for(String s:list){ //foreach不能删除
if(s.contains("a")){
list.remove(s);
}
}
System.out.println(list);
}
public void demo(){
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("abcd");
list.add("asf");
list.add("ceg");
list.add("daf");
list.add("dfs");
list.add("abc");
for(int i = 0 ; i < list.size(); i++){
String str = list.get(i);
if(str.contains("a")){ //确定是否包含字符串a
//移除
list.remove(i);
// list.remove(str);
i --;
}
//System.out.println(str);
}
System.out.println(list);
}
}