Java基础之集合
Map集合
该集合存储键值对，一对一对的往里存，并且要保证键的唯一性。
1.添加：
put(K key,V value)：添加元素。添加元素时，如果出现相同的键，后添加的值会覆盖先添加的值，并且put方法
会返回被覆盖的值。 putAll(Map<? extends K,? extends V> m)
2.删除：
clear()：清空 , remove(Object key)：根据键删除某个值，该方法返回的是被删除的那个值。
3.判断：
containsValue(Object value)：判断是否包含某个值 ,
containsKey(Object key)：判断是否包含某个键 , isEmpty()：判断是否为空。
4.获取：
get(Object key)：通过键获取该键所对应的值，可以通过get方法的返回值来判断该键是否存在。size()：获取长度。
values()：获取Map集合中所有的值。entrySet() , keySet()
Map集合共性方法演示：
import java.util.*;
class MapDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<Integer,String> map = new HashMap<Integer,String>();
sop(map.put(1,"zhangsan1"));
sop(map.put(1,"lisi1")); //添加元素。
map.put(2,"zhangsan2");
map.put(3,"zhangsan3");//添加元素。
map.put(4,null);
sop("contains:"+map.containsKey(22)); //判断是否包含某个键
sop("remove:"+map.remove(2)); //根据键删除某个值，该方法返回的是被删除的那个值
sop("get:"+map.get(4)); //通过键获取该键所对应的值
Collection<String> coll = map.values(); //获取所有的值的集合
sop(coll);
sop(map); //打印集合
}
}Map集合常见的子类对象有：Hashtable、HashMap、TreeMap
Hashtable：底层是哈希表数据结构，不可以存入null键和null值，该集合是线程同步的。JDK1.0，效率低。
HashMap：底层是哈希表数据结构，可以使用null键和null值，该集合是线程不同步的。JDK1.2，效率高。
TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序。
Map集合的两种取出方式：1.Set<K> keySet()：将Map中所有的键存入到Set集合中，因为Set集合具备迭代器，所以可以通过迭代方式取出Set集合
中所有的键，再根据Map集合的get方法获取每个键对应的值。代码示例：
import java.util.*;
class MapDemo1
{
public static void main(String[] args)
{
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(6,"lisi06");
map.put(2,"lisi02");
map.put(7,"lisi05");
map.put(3,"lisi03");
//通过Map集合中的keySet方法将Map集合中的键存入到Set集合中
Set<Integer> keySet = map.keySet();
//有了Set集合后就可以使用它的迭代器功能
for(Iterator<Integer> it = keySet.iterator(); it.hasNext(); )
{
//迭代出Set集合中所有的键
Integer key = it.next();
//根据Map集合的get方法获取每个键对应的值
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
}
}2.Map.Entry<K,V> entrySet()：将Map集合中的映射关系存入到了Set集合中，而这个关系的数据类型是Map.Entry，
通过Map.Entry中的getKey和getValue方法获取关系中的键和值。Map.Entry中的Map是一个接口，而Entry也是一个接口，
是Map接口中的一个内部接口。代码示例：
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(9,"lisi09");
map.put(3,"lisi03");
map.put(4,"lisi04");
map.put(6,"lisi06");
Set<Map.Entry<Integer,String>> entrySet = map.entrySet(); //将键值对的映射关系存入到Set集合
//迭代Set集合中的元素。
for(Iterator<Map.Entry<Integer,String>> it = entrySet.iterator(); it.hasNext(); )
{
Map.Entry<Integer,String> me = it.next();
Integer key = me.getKey(); //获取键
String value = me.getValue(); //获取值
System.out.println(key+"::"+value);
}
}
}Map集合的取出原理：将Map集合转成Set集合，再通过迭代器取出。
Collections是专门操作集合的工具类。里面有很多静态方法。sort方法是用于给List集合排序。 max方法获取集合中的最大元素。
public static <T extends Comparable<? super T>> void sort(List<T> list)：根据元素的自然顺序 对指定列表按升
序进行排序。列表中的所有元素都必须实现 Comparable 接口。
public static <T> void sort(List<T> list,Comparator<? super T> c)：根据指定比较器产生的顺序对指定列表进行排
序。此列表内的所有元素都必须是使用指定比较器可相互比较的。
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)：根据元素的自
然顺序 返回给定 collection 的最大元素。
public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)：根据指定比较器产生的顺
序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的 。
代码示例：
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list); //给List集合按照元素的自然顺序排序。
sop(list);
String max = Collections.max(list,new StrLenComparator());//按照比较器顺序获取最大值
max = Collections.max(list); //按照自然顺序获取最大值。
sop("max="+max);
}
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.sort(list); //给List集合按照元素的自然顺序排序。
Collections.sort(list,new StrLenComparator()); //按照比较器顺序进行排序。
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c) 对一个具有比较器
指定顺序的List集合进行二分查找某一个元素，如果有该元素则返回该元素的索引，否则返回：-插入点位置-1 。
代码演示：
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list); //给list集合按照自然顺序排序
sop(list);
int index = Collections.binarySearch(list,"aaa");//用二分查找法查找某一元素。
sop("index="+index);
}public static <T> void fill(List<? super T> list,T obj)：使用指定元素替换指定List集合中的所有元素。
public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)：使用另一个值替换列表中出现的所有某一指定值。
public static void reverse(List<?> list) 反转指定列表中元素的顺序。将List集合进行反转。
public static <T> Comparator<T> reverseOrder() 反转实现Comparable接口那些对象 collection 上的自然顺序。操作Set集合。public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 传入一个比较器，反转指定比较器的顺序。操作Set集合。
public static void swap(List<?> list,int i,int j) 对List集合中的两个元素进行位置置换。
public static void shuffle(List<?> list) 对List集合中的元素的位置进行随机置换。
Arrays 是用于操作数组的工具类，里面都是静态方法。
binarySearch(Object[] a, Object key) 二分查找。
copyOf：复制指定的数组。 copyOfRange：复制数组的指定范围。
equals：比较两个数组中的内容是否相同。
fill：替换数组中指定的值。
还有hashCode、sort、toString 等方法，用的时候去查文档。
public static <T> List<T> asList(T... a) ：传进来一个数组，将数组变成List集合。
把数组变成List集合的好处：
可以使用集合思想和方法来操作数组中的元素。但需要注意：将数组变成集合，不可以使用集合的增删方法，因为数组的
长度是固定的，可以使用get、contains、indexOf等这些方法，就是不可以增删。
如果操作增删方法了会发生不支持的操作异常(UnsupportedOperationException)。
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
代码示例：
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
String[] arr = {"abc","cc","kkkk"};
//把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
如果你增删。那么会反生UnsupportedOperationException,
*/
List<String> list = Arrays.asList(arr);
sop("contains:"+list.contains("cc"));
list.add("qq");
sop(list);
int[] nums = {2,4,5};
Integer[] nums = {2,4,5};
List<Integer> li = Arrays.asList(nums);
/*
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
}
public static boolean myContains(String[] arr,String key)
{
for(int x=0;x<arr.length; x++)
{
if(arr[x].equals(key))
return true;
}
return false;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}通过Collection接口中的toArray方法将集合变成数组。
示例：ArrayList<String> al = new ArrayList<String>(); String[] arr = al.toArray(String[al.size()]) ;
1.指定类型的数组应该定义为多长呢？当指定类型的数组长度小于了集合的size时，toArray方法内部会创建一个新的数
组，长度为集合的size。 当指定类型的数组长度大于了集合的size时，则不会创建新的数组了，而是使用传递进来的数
组。因此，应该创建一个长度正好的数组，所以数组的长度为al.size() 。
2.为什么要将集合变成数组？将集合变成数组是为了限制对元素的操作，防止进行增删操作。只允许查询操作，不允许增
删操作。
高级for循环
格式：for(数据类型 变量名称 ：被遍历的集合(Collection)或者数组){ }
高级for循环是对集合遍历，只能获取集合中的元素，不可以对集合进行操作，不能改变集合中的元素。而迭代器除了遍历
还可以进行remove集合中的元素。如果使用ListIterator还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for的区别：高级for有一个局限性就是必须要有被遍历的目标。
建议在遍历数组的时候还是使用传统for，因为传统for可以定义角标。代码示例：class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al) //使用增强for遍历集合中的元素。
{
System.out.println(s);
}
}
}JDK1.5版本出现的新特性 ：可变参数
示例：void show(int... arr) 。调用show(2,3,9,8) 直接往方法的参数里传递数组的元素即可。
是数组参数的简写形式，不用每次都手动的创建数组对象，只要将要操作的数组元素作为参数传递即可。
隐式的将这些参数封装成了数组。在使用方法的可变参数时，需要注意：可变参数一定要定义在参数列表的最后面。
示例：void show(String s,int... arr)。
public static void show(String str,int... arr)//可变参数要放在参数列表的最后面。
{
System.out.println(arr.length);
}StaticImport 静态导入
当类名重名时，需要指定具体的包名。当方法重名时，需要指定具体所属的对象或者类。
import static java.util.Arrays.*; 导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*; 导入了System类中所有静态成员。
当import 后面没有static的时候，导入的是类。示例：import java.util.*; 导入java.util包中所有的类。
当import后面有static的时候，导入的是一个类中的所有的静态成员。示例：import static java.util.Arrays.*; 导入
Arrays类中的静态成员。
其他对象
System类中的方法和属性都是静态的。
out：标准输出，默认是控制台。in：标准输入，默认是键盘。
Properties getProperties() ：获取系统属性信息。 示例：Properties prop = System.getProperties();
因为Properties是Hashtable的子类，也就是Map集合的一个子类对象，所以可以通过Map集合的方法取出该集合中的元素。
迭代Properties集合获取键和值，获取所有的属性信息。该集合中存储的都是字符串，没有泛型定义。
setProperty(key,value) ：在系统中自定义一些特有的信息。示例：System.setProperty("mykey","myvalue");
getProperty(key) ：获取指定的属性信息，返回的是String类型的值。
示例：String value = System.getProperty("os.name");
通过在DOS命令行输入java -D名称=值 的方式可以在jvm启动时，动态加载一些属性信息。
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{
Properties prop = System.getProperties();
for(Iterator it = prop.keySet().iterator(); it.hasNext(); ) //迭代器的方式获取集合中元素
{
Object key = it.next();
Object value = prop.get(key);
System.out.println(key+"::"+value);
}
System.setProperty("mykey","myvalue");//在系统中自定义一些特有的信息
String value = System.getProperty("os.name");//获取指定的属性信息
System.out.println("value:"+value);
for(Object key : prop.keySet()) //高级for循环获取集合中的元素
{
Object value = prop.get(key);
System.out.println(key+"::"+value);
}
}
}该类没有提供构造函数，说明不可以new对象。但是该类中的方法并不都是静态的，还有很多非静态方法，说明该类提供了方法获取本类对象，而且该方法是静态的，并且返回值类型是本类类型的。由这个特点可以看出该类使用了单例设计模式完成。
static Runtime getRuntime() ：通过该方法获取本类对象。示例：Runtime run = Runtime.getRuntime(); Process p = run.exec("C:\\Program Files\\KuGou\\KGMusic\\KuGou.exe"); p.destroy();
Date对象
Date日期的意思，Date d = new Date();因为Date类中的方法已经过时不使用了，所以找到了DateFormat类的一个子类叫SimpleDateFormat，通过SimpleDateFormat中的构造函数设置日期的模式，然后调用format方法让模式格式化指定Date对象。
SimpleDateFormat sdl = new SimpleDateFormat("yyyy年"); String sd = sdl.format(d);
Calendar c = Calendar.getInstance(); c.set(1990,8,22,11,20,30); c.add(Calendar.DAY_OF_WEEK,-3);
class CalendarDemo1
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
c.set(1990,8,22,11,20,30);
c.add(Calendar.DAY_OF_WEEK,-3);
printCalendar(c);
}
public static void printCalendar(Calendar c)
{
String[] mons = {"一月","二月","三月","四月","五月","六月",
"七月","八月","九月","十月","十一月","十二月"};
String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
String year = c.get(Calendar.YEAR)+"年";
//sop((c.get(Calendar.MONTH)+1)+"月");
int index = c.get(Calendar.MONTH);
String month = mons[index];
String day = c.get(Calendar.DAY_OF_MONTH)+"日";
int index1 = c.get(Calendar.DAY_OF_WEEK);
String week = weeks[index1];
String hour = c.get(Calendar.HOUR_OF_DAY)+":";
String min = c.get(Calendar.MINUTE)+":";
int sec = c.get(Calendar.SECOND);
sop(year+month+day+" "+week+" "+hour+min+sec);
}
}Math类
Math 类包含基本的数字操作，如指数、对数、平方根和三角函数等。
public static double abs(double a) ：返回绝对值。
public static double ceil(double a) ：返回大于指定数据的最小整数。示例：Math.ceil(16.34) ，结果是17 。
public static double floor(double a) ：返回小于指定数据的最大整数。示例：Math.floor(12.34) ，结果是12 。
public static long round(double a) ：四舍五入，取整数。示例：Math.round(12.54) ，结果为13 。
public static double pow(double a,double b) ：返回第一个参数的第二个参数次幂的值，返回a的b次幂。示例：
Math.pow(2,3),结果8
public static double random() ：返回一个大于等于0，且小于1的伪随机数。示例：int x =int(Math.random()*10+1)
另外在java.util包里有一个Random类，创建Random类对象，通过对象调用nextInt方法也可以获取随机数。
示例：Random r = new Random(); int x = r.nextInt(10)+1; 获取1到10的随机数。
随机数生成器代码示例：
import java.util.*;
class Demo
{
public static void main(String[] args) throws Exception
{
Random r = new Random(); //创建一个随机数生成器对象。
for(int x=0; x<10; x++)
{
int y = r.nextInt(10)+1; //获取1到10之间的伪随机数。
System.out.println(y);
}
}
}
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
