数组：

数组静态初始化及遍历

package wwl.array;

import java.util.Arrays;

/**

* 数组的静态初始化及数组遍历

*

*/

public class Test04 {

public static void main(String[] args) {

//定义数组，存储10个double类型数据

double [] data = new double[10];

//给元素赋值：

data[0] = 3.11;

data[4] = 78.11;

data[8] = 88.99;

//通过for循环遍历打印数组的每个元素

for (int i = 0; i < data.length; i++) {

System.out.println(data[i]);

}

/*

* 定义数组，数组会给元素进行默认初始化

* 整数数组为0

* 小数数组0.0

* 布尔类型 false

* char \u0000

* 引用类型 null

*/

//如果在定义数组的时候已经知道数组元素的值，可以在定义数组的同时给数组元素赋值。叫数组的静态初始化

//数组静态初始化时，不需要指定数组长度，数组的长度由数组初始化元素个数决定

int [] data2 = new int [] {34, 65 ,123 ,78 ,66};

//遍历元素时，还可以使用增强的for循环，也叫foreach循环

for (int xx : data2) {

//依次把data2数组的每个元素赋值给局部变量xx

System.out.print(xx + "\t");

}

System.out.println();

//数组名的相互赋值：

int[] data3 = data2; //把data2的值赋值给data3，data2的值是一个数组的引用(起始地址)

//现在data3与data2保存了同一个数组的引用，data2//data3指向了堆中同一个数组

//data3数组的元素打印

for (int yy : data3) {

System.out.print( yy + "\t");

}

System.out.println();

data3[0] = 666;

//打印data2数组元素；

//java.util.Arrays中toString()方法可以把数组的元素转化为字符串

System.out.print(Arrays.toString(data2));

}

}

数组是引用数据类型

可变长参数：

package wwl.array;

/**

* 演示可变长参数

*

*/

public class Test07 {

public static void main(String[] args) {

//再调用方法时可以传递任意整数,也可以传任意数组

sum();

sum(1);

sum(1,2);

sum(1,2,3,4,5,6,7,8,9,10);

int [] data = {56,34,76,34,786,32,78};

sum(data);

}

//定义一个方法，可以计算任意个整数的和

public static void sum( int ... data) {

//******在方法体中，把可变长参数当作数组使用

int sum = 0;

for (int xx : data) {

sum += xx;

}

System.out.println("sum = " + sum);

}

}

插入元素

package wwl.array;

import java.util.Arrays;

/**

* 在数组中插入元素分析分析！

*

*/

public class Test09 {

public static void main(String[] args) {

//数组的静态初始化

int [] data = {21,34,65,87,90,123};

//需求在索引值为2的位置插入一个数组456

int [] newdata = new int[data.length + 1];

for(int i = 0; i< 2 ; i++) {

newdata[i] = data[i];

}

newdata[2] = 456;

for(int i = 2; i

newdata[i+1] = data[i];

}

data = newdata;

System.out.println(Arrays.toString(data));

}

}

数组本质上就是堆中一块连续的存储空间

数组扩容：

package wwl.array;

import java.util.Arrays;

/**

* 数组的扩容

*

*/

public class test01 {

public static void main(String[] args) {

//定义数组直接赋值

m1();//完全手动扩容

m2();//调用System.arrayCopy实现数组元素的复制

m3();//调用Arrays工具类的copyof()方法，以后方便直接使用

}

private static void m1() {

int [] data = {1,2,3,4,5,6,7};

//1.定义更大的数组

int [] NewData = new int[data.length * 2];//按2倍大小扩容

//2.把原来数组的内容复制到新数组中

for (int i = 0; i < data.length; i++) {

NewData[i] = data[i];

}

//3.让原来的数组指向新的数组：

data = NewData;

System.out.println(Arrays.toString(data));

}

private static void m2() {

int [] data = {1,2,3,4,5,6,7};

//1.定义更大的数组

int [] NewData = new int[data.length * 2];//按2倍大小扩容

//2.把原来数组的内容复制到新数组中

//把src数组从srcPos开始的length个元素复制到dest数组的destPos位置

//System.arraycopy(src, srcPos, dest, destPos, length);

System.arraycopy(data, 0, NewData, 0, data.length);

/*

* 该方法使用native修饰，没有方法体

* JNI(Java Native Interface)可以在Java中调用其它语言编写的代码！！

*/

//3.让原来的数组指向新的数组：

data = NewData;

System.out.println(Arrays.toString(data));

}

private static void m3() {

int [] data = {1,2,3,4,5,6,7};

//Arrays.copyof(原来的数组，新的数组长度)---->实现数组的扩容

data = Arrays.copyOf(data, data.length * 2);//主要扩容方法！

System.out.println(Arrays.toString(data));

}

}

tip: data = newData:

由于数组是引用数据类型，传递的是内存使用权，是一块内存空间，它可以由多个单位同时使用。而” = “并不是赋值而是把a数组的使用权与b共享。

数组的特点：

定义一个方法删除数组中指定的元素：

具体：

static是属于类的，非static是属于对象。static方法可以通过类名访问，也可以通过类的实例访问。static方法不能访问类中非static的数据。主要区别就是有了static可以直接类名点方法调用或直接调用方法。没有的话则必须创建对象调用！

package wwl.array;

import java.util.Arrays;

/**

* 定义一个方法，实现数组元素的删除

* @param data

* @param i

*/

public class Test02 {

public static void main(String[] args) {

int [] data = {1,2,3,4,5,6,7};

data = delete(data,3);

System.out.println(Arrays.toString(data));

}

//定义方法，删除数组中指定元素，删除data数组中第i个元素

public static int[] delete(int [] data,int i) {

//1.定义较小的数组：

int[] newDAta = new int[data.length-1];

//2.把[0,1) 范围的元素复制到新数组中

for(int x = 0;x < i;x++) {

newDAta[x] = data[x];

}

//3.把[i+1,data.length)范围的元素复制到新数组[i,data.length-1中)

for(int x = i+1;x < data.length;x++) {

newDAta[x-1] = data[x];

}

//4.把新的数组返回

return newDAta;

//形参data = newDAta;不是实参

//System.out.println(Arrays.toString(data));

}

}

对象数组：

购物车例子：

二维数组

Arrays工具类：

对象数组排序：

冒泡排序分析：

最基本：

package wwl.array;

import java.util.Arrays;

public class arraymaopaopaixu {

public static void main(String[] args) {

int [] data = {21,34,65,8,90,12};

System.out.println(Arrays.toString(data));

System.out.println("------------------------------------------");

//第一轮：

for (int i = 0; i < data.length - 1; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

//第二轮：

for (int i = 0; i < data.length - 2; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

//第三轮：

for (int i = 0; i < data.length - 3; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

//第四轮：

for (int i = 0; i < data.length - 4; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

//第五轮：

for (int i = 0; i < data.length - 5; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

}

}

运行结果：

[21, 34, 65, 8, 90, 12]

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

[21, 34, 65, 8, 90, 12]

[21, 34, 65, 8, 90, 12]

[21, 34, 8, 65, 90, 12]

[21, 34, 8, 65, 90, 12]

[21, 34, 8, 65, 12, 90]

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

[21, 34, 8, 65, 12, 90]

[21, 8, 34, 65, 12, 90]

[21, 8, 34, 65, 12, 90]

[21, 8, 34, 12, 65, 90]

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

[8, 21, 34, 12, 65, 90]

[8, 21, 34, 12, 65, 90]

[8, 21, 12, 34, 65, 90]

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

[8, 21, 12, 34, 65, 90]

[8, 12, 21, 34, 65, 90]

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

[8, 12, 21, 34, 65, 90]

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

改进

package wwl.array;

import java.util.Arrays;

/**

* 改进：冒泡排序从小到大

*/

public class arraymaopaopaixu {

public static void main(String[] args) {

int [] data = {21,34,65,8,90,12};

System.out.println(Arrays.toString(data));

System.out.println("------------------------------------------");

//第一轮：

for(int j = 0;j < data.length-1 ;j++) {

for (int i = 0; i < data.length - 1 - j; i++) {

if (data[i] > data[i+1]) {

int t = data[i+1];

data[i+1] = data[i];

data[i] = t;

}

System.out.println(Arrays.toString(data));

}

System.out.println("------------------------------------------");

}

}

}

[21, 34, 65, 8, 90, 12]

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

[21, 34, 65, 8, 90, 12]

[21, 34, 65, 8, 90, 12]

[21, 34, 8, 65, 90, 12]

[21, 34, 8, 65, 90, 12]

[21, 34, 8, 65, 12, 90]

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

[21, 34, 8, 65, 12, 90]

[21, 8, 34, 65, 12, 90]

[21, 8, 34, 65, 12, 90]

[21, 8, 34, 12, 65, 90]

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

[8, 21, 34, 12, 65, 90]

[8, 21, 34, 12, 65, 90]

[8, 21, 12, 34, 65, 90]

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

[8, 21, 12, 34, 65, 90]

[8, 12, 21, 34, 65, 90]

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

[8, 12, 21, 34, 65, 90]

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

由大到小：

data[i] < data[i+1]

Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值

2.使用方法：

例：

int num = (int)(Math.random()*2+1)

以上代码即设置一个随机1到3(取不到3)的变量num。

例如：

首先Math.random()*52 //这样我们就能得到一个 >=0 且 <52的数

然后加1：Math.random()*52 + 1 //现在这个数就 >=1 且 <53

【应用场景描述：】

用Math类的random()方法产生一个字符，若该字符是一个大写英文字母，则输入 “Yes!”，否则输出“NO”。

random()方法产生的随机数在0.0和1.0之间，乘以128后，其值在0.0和128.0之间，将它转换为char类型后，用if来判断是否在’A’ 和’Z’之间。

【程序如下：】

public class IsUpper{

public static void main(String [] args){

char ch;

ch = ( char ) ( Math.random() * 128);

if ( ch >= 'A' && ch <= 'Z'){

System.out.println("Yes!");}else{

System.out.println("No!");}

}

}

例题：定义一个方法，返回长度为10的整数数组，对数组的元素进行随机初始化100内的正整数，要求数组中的元素不重复

package wwl.array;

import java.util.Arrays;

/**

* 定义一个方法，返回长度为10的整数数组，对数组的元素进行随机初始化100内的正整数，要求数组中的元素不重复

*

*/

public class test03 {

public static void main(String[] args) {

int [] mydata = getArray();

System.out.println(Arrays.toString(mydata));//和下边那句一样

System.out.println(Arrays.toString(getArray()));

}

public static int[] getArray(){

int [] data = new int[10];

for(int i = 0;i < data.length;i++) {

int xx = (int)(Math.random() * 100 + 1);

//判断xx是否在 数组中，如果xx在数组中，需要重新生成

while( exist(data, xx) ) {

xx = (int)(Math.random() * 100 + 1);

}

data[i] = xx;

}

Arrays.sort(data);//排序

return data;

}

//判断key元素是否在myarray数组中，存在返回true值

public static boolean exist(int [] myarray,int key) {

for(int i = 0;i < myarray.length;i++) {

if(key == myarray[i]) {

return true;

}

}

return false;

}

}

练习用户登录

package wwl.array;

/**

* 测试类

*/

import java.util.Scanner;

import javax.security.auth.x500.X500Principal;

public class test08 {

static Scanner sc = new Scanner(System.in);

static UserManager manager = new UserManager();

public static void main(String[] args) {

while (true) {

System.out.println("请选择你的操作");

System.out.println("\t1.用户操作,2.用户登录,3.退出程序");

int choise = sc.nextInt();

switch (choise) {

case 1:

register();

break;

case 2:

login();

break;

default:

return;// 直接结束main方法执行；

}

}

}

//用户登录

private static void login() {

System.out.println("请输入用户名");

String username = sc.next();

System.out.println("请输入密码：");

String password = sc.next();

User user = new User();

user.setUsernameString(username);

user.setPassword(password);

if (manager.userExit(user)) {

System.out.println("登陆成功");

} else {

System.out.println("用户名或密码不正确");

}

}

//用户注册

private static void register() {

System.out.println("请输入用户名");

String username = sc.next();

// 如果用户名存在，需要重新输入

while (manager.usernameExist(username)) {

System.out.println("用户名已存在，需重新输入");

username = sc.next();

}

// 对用户输入进行验证，验证用户名长度必须大于6个字符

if (username.length() <= 6) {

System.out.println("用户名长度必须大于6个字符");

return;

}

System.out.println("请输入密码：");

String password = sc.next();

// 对密码验证，要求既有字母又有数字，长度大于6

//if (password.length() <= 6) {

//System.out.println("密码长度必须大于6");

//return;

//}

while(!password.matches("(?![0-9]+$)(?![a-zA-Z]+$)\\w{6,}")) { //正则表达式！！

System.out.println("密码格式错误");

return;

}

// 创建User对象，设置User用户名和和密码，然后把user添加到数组里

User user = new User();

user.setUsernameString(username);

user.setPassword(password);

manager.add(user);

System.out.println("注册成功");

}

}

正则表达式：

package wwl.Class;

/**

* 正则表达式

* 就是一个模式串，常用于判断字符串是否匹配指定的模式

* [abc] 匹配abc中的一个，要么是a,要么是b，要么是c

* . 任意字符

* \d 数字

* \s 空白字符

* \w 单词字符[a-zA-Z0-9]

* X? 0次或一次

* X* 任意次

* X+ 至少一次

* X{n} 正好n次

* X{n,} 至少n次

* x{n,m} 至少n次最多m次

*

*/

public class zhengzebiaoda {

public static void main(String[] args) {

//1.matches()判断字符串是否匹配正则表达式格式

String emailString = "gasd54h@163.com";

//判断是否为邮箱格式

String pattern = "\\w{6,}@\\w{2,}\\.(com|net|cn)";

System.out.println(emailString.matches(pattern));

//2.replaceAll

String text = "王123";

text = text.replaceAll("\\d", "*");

System.out.println(text);

//3.split()字符串分割

text = "Good good study,day day up!";

//把字符串中的单词分离出来，英文单词之间使用空格，tab，英文标点符号

String[] words = text.split("[\\s,.!?]+");

for (String string : words) {

System.out.println(string);

}

text = "name:lisi,age:18;name:angwu,age:20;name:feifei,age:28";

//把字符串中的人的信息分离出来，创建Person对象，把这三个人的信息保存到数组中

//创建一个Person类包含姓名年龄两个字段

//把字符串的信息分离出来， split("[:,;]"); ---->4个一组

//Person[] personsss = new Person[3]----->类似前边的一个题

}

}

package wwl.array;

/**

* 用户类

*/

public class User {

private String usernameString;

private String password;

public String getUsernameString() {

return usernameString;

}

public void setUsernameString(String usernameString) {

this.usernameString = usernameString;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((password == null) ? 0 : password.hashCode());

result = prime * result + ((usernameString == null) ? 0 : usernameString.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

User other = (User) obj;

if (password == null) {

if (other.password != null)

return false;

} else if (!password.equals(other.password))

return false;

if (usernameString == null) {

if (other.usernameString != null)

return false;

} else if (!usernameString.equals(other.usernameString))

return false;

return true;

}

}

package wwl.array;

import java.util.Arrays;

/**

用户管理类，定义数组保存用户信息，定义add方法向数组添加用户，

定义一个方法usernameExist(String)判断用户名是否存在。

定义方法userExit(User)判断用户是否存在。

*

*/

public class UserManager {

private User[] usersss;//定义数组保存用户信息

private int size;//数组中用户的数量

//无参构造对用户数组初始化

public UserManager() {

usersss = new User[5];//默认长度为5

}

//通过构造方法指定用户初始化的大小,在使用数组中尽量避免频繁扩容

public UserManager(int capacity) {

usersss = new User[capacity];

}

//定义数组保存用户信息，定义add方法向数组添加用户

public void add(User u) {

//判断用户数组是否已满,

if(size >= usersss.length) {

usersss = Arrays.copyOf(usersss, usersss.length*2);

}

usersss[size] = u;

size++;

}

//定义一个方法usernameExist(String)判断用户名是否存在。

public boolean usernameExist(String username) {

for(int i = 0;i < size;i++) {

if(usersss[i].getUsernameString().equals(username)) {

return true;

}

}

return false;

}

// 定义方法userExit(User)判断用户是否存在。

public boolean userExit(User u) {

for (int i = 0; i < size; i++) {

if(usersss[i].equals(u)) {

return true;

}

}

return false;

}

}

选择排序算法：

package wwl.array;

import java.util.Arrays;

/**

* 选择最小的元素交换到前面

* 选择法排序，与冒泡排序相比交换次数减少！

*/

public class arraychoose {

public static void main(String[] args) {

int [] data = {21,34,65,8,90,12};

System.out.println(Arrays.toString(data));

System.out.println("------------------------------------------");

//找数组最小的元素交换到0位置：

for(int x = 0; x < data.length-1; x++) {

int min = x;

for (int i = min + 1; i < data.length; i++) {

if(data[i] < data[min]) {

min = i;

}

}

//把min元素交换到0位置

if(min != x) {

int t = data[x];

data[x] = data[min];

data[min] = t;

System.out.println(Arrays.toString(data));

System.out.println("------------------------------------------");

}

}

找数组第二小的元素交换到1位置：

//min = 1;

//for (int i = min + 1; i < data.length; i++) {

//if(data[i] < data[min]) {

//min = i;

//}

//}

把min元素交换到0位置

//t = data[1];

//data[1] = data[min];

//data[min] = t;

//System.out.println(Arrays.toString(data));

//System.out.println("------------------------------------------");

}

//。。。。。。。。。。。。。。。。第三第四第五等一样的操作

}

二分查找

package wwl.array;

/**

* 二分查找(折半查找)

* 二分查找的前提是数组由小到大排序

*

*/

public class Test05 {

public static void main(String[] args) {

int [] data = {8,12,21,34,65,90};

int index = binarysearch(data, 21);

System.out.println( index );

System.out.println(binarysearch(data, 8));

System.out.println(binarysearch(data, 90));

System.out.println(binarysearch(data, 100));

System.out.println(binarysearch(data, 5));

}

//在data数组中采用二分查找法，返回key元素在数组中的索引值，如果数组中不存在该元素返回-1

private static int binarysearch(int[] data, int key) {

int begin = 0;

int end = data.length - 1;//小心越界

int mid = (begin + end)/2;

while(begin <= end) {

if(data[mid] == key) {

return mid;

}else if (data[mid] < key){//查找的元素key比中间数大，说明在又半

begin = mid + 1;

mid = (begin + end)/2;

}else {//查找的元素比中间元素小，在左一半

end = end - 1;

mid = (begin + end)/2;

}

}

return -1;

}

}

== 数组练习==

package wwl.array;

import java.util.Scanner;

/**

* 定义一个存储10个int类型的数组，从键盘上输入10个整数给数组元素赋值

* 把数组的元素打印到屏幕上，要求for循环/foreach循环

* 找出数组中最大值元素的下标，打印出来

*/

public class Test06 {

public static void main(String[] args) {

//定义数组存储10个int数据

int [] data = new int[10];

Scanner input = new Scanner(System.in);

for(int i = 0; i < data.length; i++) {

System.out.println("请输入第" + (i+1) + "个数");

data[i] = input.nextInt();

}

for (int xx : data) {

System.out.print(xx);

}

//找出数组中最大值元素的下标，打印出来

int max = 0;

for(int x = max + 1 ; x < data.length;x++) {

if(data[max] < data[x]) {

max = x;

}

}

System.out.println("最大值的下标为" + max);

System.out.println("最大值的为" + data[max]);

}

}