锐客网

  1. 首页 > it技术 > >

Java高级编程

Java高级编程


集合框架


Set和List的区别
1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。




ArrayList:遍历


List list = new ArrayList<>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");


//第一种foreach
for(String str : list){
Syso(str);
}


//第二种fori
for(int i = 0; i < list.size(); i ++){
syso(list.get(i));
}


//第三种 iterator


Iterator it = list.iterator();
while(it.hasNext()){
syso(it.next());
}


Map遍历：
Map map = new Hashmap<>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");


//第一种，二次取值，通过Map.keySet遍历key和value
for(String key : map.keySet){
syso("key = " + key + " and Value = "https://www.it610.com/article/+ map.get(key));
}


//第二种 通过Map.entrySet使用iterator遍历key和value：
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Map.Entry entry = it.next();
Syso("key= " + entry.getKey() + " and value= "https://www.it610.com/article/+ entry.getValue());
}


//第三种，推荐，尤其是容量大时，Map.entrySet遍历key和value
for(Map.Entry entry : map.entrySet()){
Syso("key= " + entry.getKey() + " and value= "https://www.it610.com/article/+ entry.getValue());
}


//第四种,通过Map.values()遍历所有的value，但不能遍历key;
for (String v : map.values()) {
System.out.println("value= "https://www.it610.com/article/+ v);
}


Java 泛型http://www.runoob.com/java/java-generics.html




泛型方法：




下面是定义泛型方法的规则：
所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的）。
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。




public class GenericMethodTest
{
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}

public static void main( String args[] )
{
// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

System.out.println( "整型数组元素为:" );
printArray( intArray); // 传递一个整型数组

System.out.println( "\n双精度型数组元素为:" );
printArray( doubleArray ); // 传递一个双精度型数组

System.out.println( "\n字符型数组元素为:" );
printArray( charArray ); // 传递一个字符型数组
}
}




public class MaximumTest
{
// 比较三个值并返回最大值
public static > T maximum(T x, T y, T z)
{
T max = x; // 假设x是初始最大值
if ( y.compareTo( max ) > 0 ){
max = y; //y 更大
}
if ( z.compareTo( max ) > 0 ){
max = z; // 现在 z 更大
}
return max; // 返回最大对象
}
public static void main( String args[] )
{
System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ) );

System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
"apple", "orange", maximum( "pear", "apple", "orange" ) );
}
}




泛型类


public class Box {

private T t;

public void add(T t) {
this.t = t;
}

public T get() {
return t;
}

public static void main(String[] args) {
Box integerBox = new Box();
Box stringBox = new Box();

integerBox.add(new Integer(10));
stringBox.add(new String("菜鸟教程"));

System.out.printf("整型值为 :%d\n\n", integerBox.get());
System.out.printf("字符串为 :%s\n", stringBox.get());
}
}




类型通配符




1、类型通配符一般是使用?代替具体的类型参数。例如 List 在逻辑上是List,List 等所有List<具体类型实参>的父类。
public class GenericTest {

public static void main(String[] args) {
List name = new ArrayList();
List age = new ArrayList();
List number = new ArrayList();

name.add("icon");
age.add(18);
number.add(314);

getData(name);
getData(age);
getData(number);

}

public static void getData(List data) {
System.out.println("data :" + data.get(0));
}
}




2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。


public class GenericTest {

public static void main(String[] args) {
List name = new ArrayList();
List age = new ArrayList();
List number = new ArrayList();

name.add("icon");
age.add(18);
number.add(314);

//getUperNumber(name); //1
getUperNumber(age); //2
getUperNumber(number); //3

}

public static void getData(List data) {
System.out.println("data :" + data.get(0));
}

public static void getUperNumber(List data) {
System.out.println("data :" + data.get(0));
}
}
在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错


3.类型通配符下限通过形如 List来定义，表示类型只能接受Number及其三层父类类型，如Objec类型的实例。






Java 序列化http://www.runoob.com/java/java-serialization.html


请注意，一个类的对象要想序列化成功，必须满足两个条件：
该类必须实现 java.io.Serializable 对象。
该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。
如果你想知道一个 Java 标准类是否是可序列化的，请查看该类的文档。检验一个类的实例是否能序列化十分简单， 只需要查看该类有没有实现 java.io.Serializable接口。




http://www.runoob.com/java/java-examples.html


Java 实例 - 数组插入元素并排序


以下实例演示了如何使用sort()方法对Java数组进行排序，及如何使用 insertElement () 方法向数组插入元素, 这边我们定义了 printArray() 方法来打印数组：




public class MainClass {
public static void main(String args[]) throws Exception {
int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
Arrays.sort(array);
printArray("数组排序", array);
int index = Arrays.binarySearch(array, 1);
System.out.println("元素 1 所在位置（负数为不存在）："
+ index);
int newIndex = -index - 1;
array = insertElement(array, 1, newIndex);
printArray("数组添加元素 1", array);
}
private static void printArray(String message, int array[]) {
System.out.println(message
+ ": [length: " + array.length + "]");
for (int i = 0; i < array.length; i++) {
if (i != 0){
System.out.print(", ");
}
System.out.print(array[i]);
}
System.out.println();
}
private static int[] insertElement(int original[],
int element, int index) {
int length = original.length;
int destination[] = new int[length + 1];
System.arraycopy(original, 0, destination, 0, index);
destination[index] = element;
System.arraycopy(original, index, destination, index
+ 1, length - index);
return destination;
}
}
console:
数组排序: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8
元素 1 所在位置（负数为不存在）：-6
数组添加元素 1: [length: 11] -9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8






数组反转


ArrayList arrayList = new ArrayList();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println("反转前排序: " + arrayList);
Collections.reverse(arrayList);
System.out.println("反转后排序: " + arrayList);


反转前排序: [A, B, C, D, E]
反转后排序: [E, D, C, B, A]




获取最值


Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
int min = (int) Collections.min(Arrays.asList(numbers));
int max = (int) Collections.max(Arrays.asList(numbers));
System.out.println("最小值: " + min);
System.out.println("最大值: " + max);


数组合并


String a[] = { "A", "E", "I" };
String b[] = { "O", "U" };
List list = new ArrayList(Arrays.asList(a));
list.addAll(Arrays.asList(b));
Object[] c = list.toArray();
System.out.println(Arrays.toString(c));


[A, E, I, O, U]




Java 实例 - 数组填充


public static void main(String args[]) {
int array[] = new int[6];
Arrays.fill(array, 100);
for (int i=0, n=array.length; i < n; i++) {
System.out.print(array[i] + ",");
}
System.out.println();
Arrays.fill(array, 3, 6, 50);
for (int i=0, n=array.length; i< n; i++) {
System.out.println(ararray[i] + ",");
}
}
100,100,100,100,100,100,
100,100,100,50,50,50,




删除数组元素：ArrayList.remove(int index)




Java 实例 – 数组差集


ArrayList objArray = new ArrayList();
ArrayList objArray2 = new ArrayList();
objArray2.add(0,"common1");
objArray2.add(1,"common2");
objArray2.add(2,"notcommon");
objArray2.add(3,"notcommon1");
objArray.add(0,"common1");
objArray.add(1,"common2");
objArray.add(2,"notcommon2");
System.out.println("array1 的元素" +objArray);
System.out.println("array2 的元素" +objArray2);
objArray.removeAll(objArray2);
System.out.println("array1 与 array2 数组差集为："+objArray);


array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon, notcommon1]
array1 与 array2 数组差集为：[notcommon2]


数组交集


ArrayList objArray = new ArrayList();
ArrayList objArray2 = new ArrayList();
objArray2.add(0,"common1");
objArray2.add(1,"common2");
objArray2.add(2,"notcommon");
objArray2.add(3,"notcommon1");
objArray.add(0,"common1");
objArray.add(1,"common2");
objArray.add(2,"notcommon2");
System.out.println("array1 数组元素："+objArray);
System.out.println("array2 数组元素："+objArray2);
objArray.retainAll(objArray2);
System.out.println("array2 & array1 数组交集为："+objArray);


Java 实例 - 判断数组是否相等


Arrays.equals(ary, ary1)


数组并集




public static void main(String[] args) throws Exception {
String[] arr1 = { "1", "2", "3" };
String[] arr2 = { "4", "5", "6" };
String[] result_union = union(arr1, arr2);
System.out.println("并集的结果如下：");

for (String str : result_union) {
System.out.println(str);
}
}

// 求两个字符串数组的并集，利用set的元素唯一性
public static String[] union(String[] arr1, String[] arr2) {
Set set = new HashSet();

for (String str : arr1) {
set.add(str);
}

for (String str : arr2) {
set.add(str);
}

String[] result = {};

return set.toArray(result);
}




格式化时间（SimpleDateFormat）


Date date = new Date();
String strDateFormaat = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat sdf = new SimpleDateFormat(strDateFormaat);
System.out.println(sdf.format(date));


时间戳转换成时间：


Long timeStamp = System.currentTimeMillis();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String sd = sdf.format(new Date(Long.parseLong(String.valueOf(timeStamp))));















    推荐阅读


    上一篇：单片机开发，主函数没调用任何程序，串口一直收到00 0 FF之类的数据

    下一篇：SQL|Worktable大量逻辑读