package javaStudy;
/**
*
* @author zhaocx1
*
*/
import java.util.ArrayList;//导入集合中的类包
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* 高级for循环
* 格式：
* for(数据类型 变量名：被遍历的集合(Collection)或者数组)
* {}
* 对集合进行遍历。
* 只能获取元素，不能对集合进行操作。
*
* 迭代器除了遍历，还可以进行remove集合中元素的动作。
* 如果使用ListIterator,还可以在遍历过程中进行对集合进行增删改查的动作。
*
* 传统for和高级for有什么区别呢？
* 高级for有一个局限性：必须有被遍历的目标。
*
* 建议：
* 在遍历数组的时候，还是希望用传统for，因为传统for可以去角标。
*/
public class StrongForDemo {
public static void main(String[] args) {
// //定义一个集合容器用于存储集合，并指定泛型为字符串类型
ArrayList<String> a1 = new ArrayList<String>();
// 添加元素
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
// 增强for循环，对集合中的元素进行遍历
for (String s : a1) {
// s="kk";
System.out.println(s);
}
// 输出打印集合中的元素
System.out.println(a1);
// 用迭代器取出集合中的元素
/*
* Iterator<String> it=a1.iterator();while(it.hasNext())
* {System.out.println(it.next());}
*/
// 定义一个数组，取出数组中的元素
int[] arr = { 3, 5, 1 };
for (int i : arr) {
System.out.println("i:" + i);
}
//定义一个集合容器用于存储集合，并指定泛型为字符串类型
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 添加元素
hm.put(1, "a");
hm.put(2, "b");
hm.put(3, "c");
// 增强for循环，用Map集合中的keySet方法对集合中的元素进行遍历
Set<Integer> keySet = hm.keySet();
for (Integer k : keySet) {
System.out.println(k + "::" + hm.get(k));
}
// 增强for循环，用Map集合中的Map.Entry方法对集合中的元素进行遍历
for (Map.Entry<Integer, String> me : hm.entrySet()) {
System.out.println(me.getKey() + "......" + me.getValue());
}
}
}
package javaStudy;
import java.util.ArrayList;//导入集合中的类包
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
*
* @author zhaocx1
*
*/
/*
* 集合框架的工具类。 Collections:集合框架的工具类。里面定义的都是静态方法。
*
* Collections和Collection有什么区别？ Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
* 它有两个常用的子接口， List：对元素都有定义索引。有序的。可以重复元素。 Set：不可以重复元素。无序。
*
* Collections是集合框架中的一个工具类。该类中的方法都是静态的 提供的方法中有可以对list集合进行排序，二分查找等方法。
* 通常常用的集合都是线程不安全的。因为要提高效率。 如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
*/
// 定义一个类实现一个比较器接口
class StrLenComparator implements Comparator<String> {
// 覆写比较器中的compare方法，并以字符串类型作为参数
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 class CollectionsDemo1 {
public static void main(String[] args) {
//sortDemo();
maxDemo();
}
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);
//打印集合中的元素
sop(list);
//获取集合中的最大值
String max = Collections.max(list/* ,new StrLenComparator() */);
//打印集合中的最大值
sop("max=" + max);
}
public static void sortDemo() {
//定义一个集合容器用于存储集合，并指定泛型为字符串类型
List<String> list = new ArrayList<String>();
//添加元素
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("kkkk");
list.add("qq");
list.add("z");
//打印操作前集合中的元素
sop(list);
//集合工具类中通过sort进行排序
Collections.sort(list,new StrLenComparator());
// Collections.sort(list);
//打印操作后集合中的元素
sop(list);
}
public static void sop(Object obj) {//定义一个静态打印方法，接受的参数类型为Object类
System.out.println(obj);
}
}
package javaStudy;
import java.util.ArrayList;//导入集合中的类包
import java.util.Collections;
import java.util.List;
/**
*
* @author zhaocx1
* 练习：通过这般查找的方式找出某个元素在集合中的角标位置
*/
public class BinarysearchDemo {
public static void main(String[] args) {
binarySearchDemo();//调用静态方法
}
public static void binarySearchDemo() {//定义一个静态方法
//定义一个集合容器用于存储集合，并指定泛型为字符串类型
List<String> list = new ArrayList<String>();
//添加元素
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("kkkk");
list.add("qq");
list.add("z");
//对集合中的元素进行排序
Collections.sort(list);
//打印集合中的元素
sop(list);
//通过这般查找方法找出某一元素在集合中的角标位置
int index = Collections.binarySearch(list, "qq");
//打印角标位置
sop("index:" + index);
}
public static void sop(Object obj) {//定义一个静态打印方法，接受的参数类型为Object类
System.out.println(obj);
}
}
/*
* class StrLenComparator2 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); } }
*/
package javaStudy;
import java.util.Arrays;//导入集合中的包类
import java.util.List;
/**
*
* @author zhaocx1
* 练习：通过这般查找的方式找出某个元素在集合中的角标位置
*/
/*
* Arrays：用于操作数组的工具类。
* 里面都是静态的方法。
*
* asList:将数据变成list集合。
*/
class ArraysDemo {
public static void main(String[] str) {
// int[] arr={2,4,5};
// System.out.println(Arrays.toString(arr));
//定义一个字符串数组
String[] arr = { "abc", "cc", "kkk" };
// 把数组变成list集合有什么好处？
// 可以使用集合的思想和方法来操作数组中的元素。
// 注意：将数据变成集合，不可以使用集合的增删方法。
// 因为数据的长度是固定的。
// contains get indexOf(); subList();
// 如果增删，那么会出现不支持操作异常。
//通过Arrays工具类中的aslist方法将数组变成集合
List<String> list = Arrays.asList(arr);
// 判断是否包含某一个元素
sop("contains:" + list.contains("cc"));
// list.add("qq");//UnsupportedOperationException, 不支持的异常。
//打印集合中的元素
sop(list);
int[] nums = { 2, 4, 5 };
//Integer nums={2,4,5};
List<int[] /* Integer */> li = Arrays.asList(nums);
/*
* 如果数组中的元素都是对象，那么变成集合时，数据中的元素就直接转成集合中的元素。
* 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
sop(li);
}
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);
}
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
import java.util.ArrayList;//导入集合包中的类包
import java.util.Collections;
import java.util.List;
public class FillDemo {
public static void main(String[] args) {
replaceAllDemo();// 调用静态方法
}
// 定义一个静态方法
public static void replaceAllDemo() {
// 定义一个集合容器用于存储集合，并指定泛型为字符串类型
List<String> list = new ArrayList<String>();
// 添加元素
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("kkkk");
// 打印操作前集合中的元素
sop(list);
// 对集合中的元素进行替换
Collections.replaceAll(list, "aaa", "qq");
// 打印操作后集合中的元素
sop(list);
// 对集合进行反转
Collections.reverse(list);
// 打印操作后集合中的元素
sop(list);
}
/*
* fill方法可以将集合中所有元素替换成指定元素。
*
* 练习： 将list集合中部分元素替换中指定元素。
*/
// 定义一个静态方法
public static void fillDemo() {
// 定义一个集合容器用于存储集合，并指定泛型为字符串类型
List<String> list = new ArrayList<String>();
// 添加元素
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("kkkk");
// 打印操作前集合中的元素
sop(list);
// 将集合中的元素全部替换成pp
Collections.fill(list, "pp");
// 打印操作后集合中的元素
sop(list);
}
public static void sop(Object obj) {// 定义一个静态打印方法，接受的参数类型为Object类
System.out.println(obj);
}
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
/*
* JDK1.5版本出现的新特性。 方法的可变参数。 在使用时注意：可变参数一定要定义在参数列表最后面。
*/
class ParamMethodDemo {
public static void main(String[] args) {
// show(3,4);
/*
* //虽然少定义了多个方法。 但是每次都要定义一个数组。作为实际参数。
*
* int[] arr = {3,4}; show(arr);
*
* int[] arr1 = {2,3,4,5}; show(arr1);
*/
/*
* 可变参数。 其实就是上一种数组参数的简写形式。 不用每一次都手动的建立数组对象。 只要将要操作的元素作为参数传递即可。
* 隐式将这些参数封装成了数组。
*/
show("haha", 2, 3, 4, 5, 6);
// show(2,3,4,5,6,4,2,35,9,"heh");
}
public static void show(String str, int... arr) {
System.out.println(arr.length);
}
/*
* public static void show(int a,int b) { System.out.println(a+","+b); }
* public static void show(int a,int b,int c) {}
*/
}
package javaStudy;
/**
*
* @author zhaocx1
*
*/
/*
* StaticImport 静态导入
* 当类名重名时，需要指定具体的包名。
* 当方法重名时，指定具备所属的对象或者类。
*/
import static java.lang.System.out;//导入了System中所有静态成员。
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.sort;
import java.util.ArrayList;
import java.util.Arrays;//导入集合包中的类包
//packa/Demo.class
//packb/Demo.class
//import packa.*;
//import packb.*;
class StaticImportDemo //extends Object
{
public static void main(String[] args)
{
//输出打印内容
out.println("haha");
//声明一个整形数组
int[] arr = {3,1,5};
//对数组中的元素进行排序
sort(arr);
//通过这般查找某一个元素的角标位置
int index = binarySearch(arr,1);
//打印角标
System.out.println("Index="+index);
//将数组转化成字符串
out.println("..."+Arrays.toString(arr));
//定义一个集合容器用于存储集合，
ArrayList al = new ArrayList();
//添加元素
al.add(1);
al.add(3);
al.add(2);
//打印操作前的集合中的元素
out.println(al);
//对集合中的元素进行排序
sort(al);
//打印操作后的集合中的元素
out.println(al);
}
}
package javaStudy;
import java.util.ArrayList;//导入集合包中的类包
import java.util.Arrays;
/**
*
* @author zhaocx1
*
*/
/*
* 集合变成数据。
*/
public class CollectionChangeToArray {
public static void main(String[] args) {
//定义一个集合容器用于存储集合，
ArrayList<String> a1 = new ArrayList<String>();
//添加元素
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
/*
* 1.指定类型的数组到底定义多长呢？ 当指定类型的数组长度小于集合的size,那么该方法内会创建一个新的数组。长度为集合的size.
* 当指定类型的数组长度大于集合的size，就不会新创建数组，而是使用传递进来的数组。
*
* 所以创建一个刚刚好的数组最优。
*
* 2.为什么要将集合变数组？ 为了限定对元素的操作，不需要进行增删了。
*/
//将集合编程数组
String[] arr = a1.toArray(new String[a1.size()]);
System.out.println(Arrays.toString(arr));
}
}
package Java学习;
/**
*
* @author zhaocx1
*
*/
import java.text.SimpleDateFormat;//导入text包中的类包
import java.util.Date;//导入集合中的类包
public class DateDemo {
public static void main(String[] args)
{
Date d=new Date();
System.out.println(d);//打印的时间看不懂，希望有些格式。
//将模式封装到SimpleDateformat对象中。
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月d日 E hh:mm:ss");
//调用format方法让模式格式化指定Date对象。
String time=sdf.format(d);
//输出打印内容
System.out.println("time="+time);
}
}
package JavaStudy;
/**
*
* @author zhaocx1
*
*/
/*
* System:类中的方法和属性都是静态的。
* out:标准输出，默认是控制台。
* in:标准输入，默认是键盘。
*
* 描述系统一些信息。
* 获取系统 属性信息：Properties getProperties()；
*
*/
import java.util.Properties;//导入集合包中的类包
public class SystemDemo {
public static void main(String[] args)
{
Properties prop=System.getProperties();
//因为Properties是Hashtable的子类，也就是Map集合中的一个子类对象。
//那么可以通过Map的方法取出该集合中的元素。
//该集合中存储的都是字符串，没有泛型定义。
//如何在系统中自定义一些特有信息呢？
System.setProperty("myKey","myvalue");
//获取指定属性信息。
String value=System.getProperty("os.name");
System.out.println("value="+value);
//可不可以jvm启动时，动态加载一些属性信息呢？
String v=System.getProperty("haha");
System.out.println("v="+v);
/* 获取所有属性信息。
for(Object obj:prop.keySet())
{
String value=(String)prop.get(obj);
System.out.println(obj+"::"+value);
}
*/
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
