java学习小记 数组及其方法 结构体

接上一篇博文

数组

java作为一门面向对象的语言，数组是一种特殊的对象。

数组在定义时，不能分配空间。只有定义完后，可以给数组分配空间。

在Java中，无论使用数组或容器，都有边界检查。如果越界操作就会得到一个RuntimeException异常。

一维数组

public class Main
{
	public static void main (String[] args)
	{
		// 静态初始化 
		int intArray[]={1,2,3,4};     
		String stringArray[]={"abc", "How", "you"}; 
		// 动态初始化
		int data[];  //声明数组时不规定长度
		data = new int[5]; 
		int []array=new int[6];
	}
}

多维数组

Java语言中，多维数组被看作数组的数组。以二维数组为例。
Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

public class Main
{
	public static void main (String[] args)
	{
		// 静态初始化 
		int abc[][]={{1,2},{2,3},{3,4,5}};
		//   动态初始化
		// 1) 直接为每一维分配空间，格式如下： 
		// int arrayName = new type[arrayLength1][arrayLength2]; 
		int ab[][] = new int[2][3];

		/* 2) 从最高维开始，分别为每一维分配空间： 
		　　arrayName = new type[arrayLength1][]; 
		　　arrayName[0] = new type[arrayLength20]; 
		　　arrayName[1] = new type[arrayLength21]; 
		　　… 
		　　arrayName[arrayLength1-1] = new type[arrayLength2n]; 

		　　例： */
		int a[][] = new int[2][];
		a[0] = new int[3];
		a[1] = new int[5];

		/* 对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。 
		　　而且，必须为每个数组元素单独分配空间。 
		　　例如： */
		String s[][] = new String[2][ ]; 
		s[0]= new String[2]; //为最高维分配引用空间 
		s[1]= new String[2]; //为最高维分配引用空间 
		s[0][0]= new String("Good");// 为每个数组元素单独分配空间 
		s[0][1]= new String("Luck");// 为每个数组元素单独分配空间 
		s[1][0]= new String("to");  // 为每个数组元素单独分配空间 
		s[1][1]= new String("You"); // 为每个数组元素单独分配空间
	}
}

数组的方法

一、System.arraycopy

Java标准类库提供static方法System.arraycopy(),用它复制数组比用for循环复制要快得多，System.arraycopy()针对所有的类型做了重载，需要5个参数。
第一个参数：源数组。
第二个参数：偏移量,即从哪个位置开始复制的索引。
第三个参数：目标数组。
第四个参数：偏移量。
第五个参数：要从源数组中复制到目标数组元素的个数,一般情况下为目标数组的长度。
例：
从A数组中复制元素到B数组

public class Practice
{
	public static void main (String[] args)
	{
		String[] A = {"H","e","l","l","o"}; 
		String[] B = new String[3]; 
		System.arraycopy(A, 0, B, 1, B.length-1); 
		for (int i = 0; i < B.length; i ++)
			System.out.print(B[i] + " "); 
	}
}

运行结果为：null H e;

二、Arrays.Fill

此方法用于填充数组。

import java.util.*;

public class Practice
{
	public static void main(String[] args)
	{
		String[] A = new String[5];
		Arrays.fill(A, "Hello");
		for (int i=0;i<A.length;i++)
			System.out.print(A[i] + " "); 
	}
}

运行结果为：
Hello Hello Hello Hello Hello

三、Array.equals

比较两个数组A、B是否相等，此方法针对所有基本类型与object都作了重载，例如比较两个数是否相等用Integer.equals()方法……，通过object.equals()方法比较数组是否相等，是基于内容的。

import java.util.*;

public class Practice
{
	public static void main(String[] args)
	{
		String[] A = {"1","2","3"}; 
		String[] B = {"一","二","三"}; 
		String[] C = {"1","2","3"}; 
		System.out.println(Arrays.equals(A, B));
		System.out.println(Arrays.equals(A, C));
	} 
}

运行结果为：false true

四、Array.asList

此方法用于输出数组中的所有数.

例：
输出已知数组A中的所有数

import java.util.*;

public class Practice
{
	public static void main(String[] args)
	{
		String[] A = {"H","e","l","l","o"}; 
		System.out.println(Arrays.asList(A)); 
	}
}

运行结果为： [H, e, l, l, o]

五、数组中的排序

使用内置的排序方法，就可以对任意的基本类型数组排序，也可以对任意的对象数组进行排序，只要该对象实现了Comparable接口或具有相关联的Comparator接口
例：
已经数组String[]
A ={"A","B","c","D","e","f","G","H"};现对数组A进行排序，要求忽略大小写排序
分析：String默认的排序方法，第一步是将大写字母开头的词均放在小写字母头的词的前面，然后才进行排序。
如：String[]
A ={"A","B","c","D","e","f","G","H"};

Arrays.sort(A);

System.out.println(Arrays.asList(A));

运行结果为：[A, B, D, G, H, c, e, f];

如果想忽略大小写，可以通过自定义排序方式来实现：

import java.util.*;

public class Practice implements Comparator
{
	public static void main(String[] args)
	{
		String[] A = {"A","B","c","D","e","f","G","H"}; 
		Arrays.sort(A,new Practice()); 
		System.out.println(Arrays.asList(A));
	}
	public int compare (Object o1, Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;
		return s1.toLowerCase().compareTo(s2.toLowerCase());
	} 
}

运行结果为：[A, B, c, D, e, f,
G,H]

六、Arrays.binarySearch

使用Arrays.binarySearch()执行快速查找。
注意：不要对未排序的数组使用binarySearch();

例：快速查找数组A中的元素

import java.util.*;

public class Practice
{  
    public static void main (String[] args)
    {
    	String[] a = {"a","d","e","w","f"}; 
    	Arrays.sort(a); 
    	System.out.println(Arrays.asList(a)); 
    	int index1 = Arrays.binarySearch(a, "f"); 
    	System.out.println("要查找的值存在的时候：" + index1); 
    	int index2 = Arrays.binarySearch(a, "n"); 
    	System.out.println(index2);
    	index2 = -index2 - 1; 
    	System.out.print("当不存在的时候输出该值最可能存在的位置：" + index2); 
    }
}

运行结果：
[a, d, e, f, w]

要查找的值存在的时候：3

-5

当不存在的时候输出该值最可能存在的位置：4

七、Arrays.copyOf

这个方法是将原数组快速复制成一个新数组。如果新数组的长度小于旧数组的长度，将截取一部分旧数组中的元素，复制给新数组，
反之，如果大于旧数组的长度，则将以0，null，或false给予补充。

例：快速复制数组

import java.util.*;

public class Practice
{   
    public static void main (String[] args)
    {
    	String[] a = {"a","d","e","w","f"}; 
    	String[] b = new String[4]; 
    	String[] c = new String[5]; 
    	String[] d = new String[6]; 
    	b = Arrays.copyOf(a, b.length); 
    	c = Arrays.copyOf(a, c.length); 
    	d = Arrays.copyOf(a, d.length); 
    	System.out.println("b数组的元素：" + Arrays.asList(b)); 
    	System.out.println("c数组的元素：" + Arrays.asList(c)); 
    	System.out.println("d数组的元素：" + Arrays.asList(d)); 
    } 
}

运行结果为：

b数组的元素：[a, d, e, w]

c数组的元素：[a, d, e, w, f]

d数组的元素：[a, d, e, w, f, null]

八、Arrays.copyOfRange

这个方法与前面介绍的Arrays.copyOf()的用法相似，type[]N
= Arrays.copyofRange("原数组",i,j)就是复制原数组赋值给新的数组N,指定从索引i到j，包括i，不包括j;

例：将原数组指定复制一个新数组

import java.util.*;

public class Practice
{   
    public static void main(String[] args)
    {
    	String[] a = {"a","d","e","w","f"}; 
    	String[] b = new String[4]; 
    	b = Arrays.copyOfRange(a, 2, 4); 
    	System.out.println("b数组的元素：" + Arrays.asList(b)); 
    } 
}

运行结果为： b数组的元素：[e,
w]
注：貌似这个方法不会用null来填充剩余元素

九、Arrays.deepToString

这个方法的用法同 Arrays.asList() 的用法相似,此方法是为了将多维数组转换为字符串而设计的；

下面通过例子来看一下它们的相同点。

例：输出已知数组a中的元素。

import java.util.*;

public class Practice
{   
    public static void main(String[] args)
    {
    	String[] a = {"a","d","e","w","f"};
    	System.out.println("用Arrays.asList()方法输出：" + Arrays.asList(a));
    	System.out.println("用Arrays.deepToString()方法输出：" + Arrays.deepToString(a));
    }
}

运行结果为：

用Arrays.asList()方法输出：[a,
d, e, w, f]

用Arrays.deepToString()方法输出：[a, d, e, w, f]

十、Arrays.deepEquals

此方法与Arrays.equals(Object[],Object[])
方法不同，此方法适用于任意深度的嵌套数组。

如果两个数组引用均为 null，或者它们引用了包含相同元素数量的数组，并且两个数组中的所

有相应元素对都是深层相等的，则认为这两个数组引用是深层相等的。

例：已知三个三维数组间的比较。

import java.util.*;

public class Practice
{
	public static void main (String[] args)
	{
		String[][][] d = new String[2][2][2]; 
		d[1][1][1] = "a"; 
		String[][][] e = new String[3][3][3]; 
		e[1][1][1] = "a"; 
		String[][][] f = new String[2][2][2]; 
		f[1][1][1] = "a"; 
		String[][][] g = new String[2][2][2]; 
		g[1][1][1] = "ab"; 
		
		System.out.println("--------------------------"); 
		System.out.println("输出equals()方法与deepEquals()方法的区别；"); 
		System.out.println("数组d与数组f进行比较： " + d.equals(f)); 
		System.out.println("数组d与数组f进行比较： " + Arrays.deepEquals(d, f)); 
		System.out.println("--------------------------"); 
		
		//下面输出比较结果 
		System.out.println("================================="); 
		System.out.println("数组d与数组e进行比较： " + Arrays.deepEquals(d, e)); 
		System.out.println("数组d与数组g进行比较： " + Arrays.deepEquals(d, g));  
		System.out.println("================================="); 
	} 
}

运行结果：
--------------------------

输出equals()方法与deepEquals()方法的区别；

数组d与数组f进行比较： false

数组d与数组f进行比较： true

--------------------------

=================================

数组d与数组e进行比较： false

数组d与数组g进行比较： false

=================================

十一、Collections.reverseOrder

反转自然的顺序

例：用除了循环外的另一方式逆向输出已知数组a

import java.util.*;

public class Practice
{
    public static void main (String[] args)
    {
    	String[] a = {"a","b","c"};
    	Arrays.sort(a,Collections.reverseOrder());
    	System.out.println(Arrays.asList(a));  
    }
}

运行结果为：[c,
b, a]

结构体

结构体及其排序
以下转自：Java学习(3)_结构体_AekdyCoin的空间_百度空间

compareTo中，返回-1类似C++中重载的'<'

Arrays.sort(long A[],int L,int R);

longA[]表示等待排的数组在[L,R)内排

import java.io.*;
import java.util.*;
import java.math.*;
import java.text.*;

class Node implements Comparable
{
    public int val;
    public Node(int v) {this.val=v;}
    public int compareTo (Object obj)
    {
//instanceof是Java的一个二元操作符它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据
    	if (obj instanceof Node)
    	{
            Node tmp=(Node)obj;
            if (this.val<tmp.val)
                return -1;
            if (this.val>tmp.val)
                return 1;
        }
        return 0;
    }
}

public class Main
{
    public static void main(String args[]) throws Exception
    {
        int i;
        Scanner cin=new Scanner(System.in);
        Node a[]=new Node[4];
        for (i=0;i<4;i++)
        	a[i]=new Node(i+1);
        Arrays.sort(a);
        for (i=0;i<4;i++)
            System.out.print(a[i].val+((i==3)?"\n":" "));
    }
}

结构体 自定义其方法

import java.io.*;
import java.util.*;
import java.math.*;
import java.text.*;

class stack
{
    private int a[]=new int[1001],top;
    public stack() {top=0;}
    public void push(int val) {a[top++]=val;}
    public boolean empty() {return top==0;}
    public int pop ()
    {
    	if (top==0)
    	{
    		System.out.println("警告:栈为空!");
    		return -1;
    	}
    	return this.a[--top];
    }
}

public class Main
{
    public static void main(String args[]) throws Exception
    {
        stack S=new stack();
        S.push(5);
        S.push(7);
        S.push(98);
        S.push(123);
        while (!S.empty())
            System.out.print(S.pop()+" ");
    }
}

以下代码参考了：java中对ArrayList进行排序 - 三不眨眼的日志 - 网易博客

import java.util.*;

class Student
{
	String name;
	int age;
	Student (String str, int tmp)
	{
		name = str;
		age = tmp;
	}
}

public class Main
{
	public static void main(String[] args)
	{
		Student zlj = new Student("丁晓宇", 21);
		Student dxy = new Student("赵四", 22);
		Student cjc = new Student("张三", 11);
		Student lgc = new Student("刘武", 19);
		List<Student> studentList = new ArrayList<Student>();
		studentList.add(zlj);
		studentList.add(dxy);
		studentList.add(cjc);
		studentList.add(lgc);

		Collections.sort(studentList, new SortByAge());
		for (Student student : studentList)
			System.out.println(student.name + " / " + student.age);

		System.out.println("  =  ");
		Collections.sort(studentList, new SortByName());
		for (Student student : studentList)
			System.out.println(student.name + " / " + student.age);
	}
}

class SortByAge implements Comparator
{
	public int compare (Object o1, Object o2)
	{
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		if (s1.age > s2.age)
			return 1;
		return 0;
	}
}

class SortByName implements Comparator
{
	public int compare (Object o1, Object o2) 
	{
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		return s1.name.compareTo(s2.name);
	}
}