第二周进度报告
这一周主要学习了Java和数据结构的基础知识
其中Java主要学习了数组的使用,方法的概念与使用,使用Java语言完成一些简单的算法(质数判断),二维数组
,以及Java语言面向对象的知识,以及学习了封装
数据结构继续学习了顺序表以及链表的各种功能的实现,以及循环链表和双向链表
接下来我会继续学习Java和数据结构更深入的知识,以案例为主,规划自己的学习内容
数组
数组是一个容器,可以用来存储同种数据类型的多个元素.
格式一:int [] array
格式二:int array[]
数组的初始化:就是在内存中,为数组容器开辟空间,并将数据存入容器的过程.
int[] array = new int[]{}
简写:int[] array = {}
package me.JavaStudy;
public class Test1 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
System.out.println(array);
}
}
//[I@7b23ec81
// [ 表示这是一个数组
// I 表示该数组的类型
// @ 表示一个间隔符号,固定格式
// 7b23ec81 才是数组的真正地址(十六进制)
数组长度 = 数组名.length
package me.JavaStudy;
public class Test1 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
//array.fori IDEA快捷遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
数组的动态初始化:int[] arr = new int [10];
数组具有默认初始化值
整数 0
小数 0.0
字符 '/u0000' 空格
布尔类型 false
引用数据类型 null
//打乱数组
package me.JavaStudy;
import java.util.Random;
public class Test1 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
Random r = new Random();
for (int i = 0; i < array.length; i++) {
int randomIndex = r.nextInt(array.length);
int temp = array[i];
array[i] = array[randomIndex];
array[randomIndex] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
- 栈 方法运行时使用的空间
- 堆 存储对象或数组,new来创建的,都存储在堆内存
- 只要是new出来的一定在堆里面开辟了一个小空间
- 如果new了多次,那么在堆里面有多个小空间,每个小空间都有各自的数据
方法
方法是程序中最小的执行单元
- 重复代码,具有独立功能的代码可以抽取到方法中.
- 可以提高代码的复用性和可维护性
package me.JavaStudy;
//带参数的方法
public class Test1 {
public static void main(String[] args) {
getSum(10,20);
}
public static void getSum(int number1,int number2){
int result = number1 + number2;
System.out.println(result);
}
}
package me.JavaStudy;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
int a,b,c,d;
Scanner sc = new Scanner(System.in);
a = sc.nextInt();
b = sc.nextInt();
c = sc.nextInt();
d = sc.nextInt();
boolean bo = isEqual(a,b,c,d);
if(bo){
System.out.println("相等");
}
else System.out.println("不相等");
}
public static boolean isEqual(int a,int b,int c,int d){
if(a*b == c*d)return true;
return false;
}
}
方法的格式:
public static 返回值类型 方法名 (参数){
方法体;
return 返回值;
}
各种基本方法实现
package me.JavaStudy;
public class Test1 {
public static void main(String[] args) {
int[] a = {1,2,356,4,5,6,78};
int[] copy = copyOfRange(a,1,4);
printarr(copy);
}
//打印数组
public static void printarr(int[] arr){
System.out.printf("[");
for (int i = 0; i < arr.length; i++) {
if(i != arr.length-1){
System.out.print(arr[i]+",");
}
else System.out.print(arr[i]);
}
System.out.printf("]");
}
//求最大值
public static int getMax(int[] arr){
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
//判断一个数在数组中是否存在
public static boolean isExist(int[] arr,int target){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == target)return true;
}
return false;
}
//拷贝数组
public static int[] copyOfRange(int[] arr,int from ,int to){
int index = 0;
int[] newArr = new int[to - from];
for(int i = from; i < to; i++){
newArr[index] = arr[i];
index++;
}
return newArr;
}
}
基本数据类型:数据值时存储在自己的空间中
- 特点:赋值给其他变量,也是赋的真实的值
引用数据类型:数据值时存储在替他空间中,自己空间中存储的是地址值 - 特点: 赋值给其他变量,赋的是地址值.
package me.studyJava;
public class Test1 {
public static void main(String[] args) {
int count = 0;
for (int i = 100; i <= 200; i++) {
if(isPrime(i))count++;
}
System.out.println(count);
}
//判断是否为质数的方法
public static boolean isPrime(int x) {
for(int i = 2; i <= Math.sqrt(x); i++){
if(x % i == 0){
return false;
}
}
return true;
}
}
//生成验证码
package me.JavaStudy;
import java.util.Random;
//生成验证码
public class Test {
public static void main(String[] args) {
char[] ch = new char[52];
for (int i = 0; i < ch.length; i++) {
if(i <= 25){
ch[i] = (char)('a' + i);
}
else{
ch[i] = (char)('A' + i - 26);
}
}
/* for (int i = 0; i < ch.length; i++) {
System.out.printf(ch[i] + " ");
}*/
String result = "";
Random r = new Random();
for (int i = 0; i < 4; i++) {
int randomIndex = r.nextInt(ch.length);
result += ch[randomIndex];
}
int randomNum = r.nextInt(10);
result += randomNum;
System.out.println(result);
}
}
//抽奖游戏
package me.JavaStudy;
import java.util.Random;
//抽奖游戏
public class Test {
public static void main(String[] args) {
int[] money = {2,588,888,1000,10000};
Random r = new Random();
int count = 5;
while(count != 0){
int randomIndex = r.nextInt(5);
if(money[randomIndex] != 0){
System.out.println(money[randomIndex] + "被抽中了");
money[randomIndex] = 0;
count--;
}
}
}
}
//抽奖游戏加强代码 --打乱数组
package me.JavaStudy;
import java.util.Random;
//抽奖游戏代码优化 --打乱数组
public class Test {
public static void main(String[] args) {
int[] money = {2,588,888,1000,10000};
Random r = new Random();
for (int i = 0; i < money.length; i++) {
int randomIndeax = r.nextInt(money.length);
int temp = money[i];
money[i] = money[randomIndeax];
money[randomIndeax] = temp;
}
for (int i = 0; i < money.length; i++) {
System.out.println(money[i]);
}
}
}
//双色球彩票模拟系统
package me.JavaStudy;
import java.util.Random;
import java.util.Scanner;
//抽奖游戏代码优化 --打乱数组
public class Test {
public static void main(String[] args) {
//生成中奖号码
int[] arr = creatArr();
//用户输入号码
int[] userArr = userInput();
//判断是否中奖
int redCount = 0,blueCount = 0;
for (int i = 0; i < userArr.length-1; i++) {
if(isExist(arr,userArr[i])){
redCount++;
}
}
if(arr[arr.length-1] == userArr[userArr.length-1])blueCount++;
System.out.print("中奖号码为:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
if(redCount == 6 && blueCount == 1){
System.out.println("恭喜中奖1000万!");
}
else if(redCount == 6 && blueCount == 0){
System.out.println("恭喜中奖500万!");
}
else if(redCount == 5 && blueCount == 1){
System.out.println("恭喜中奖3000!");
}
else if(redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1){
System.out.println("恭喜中奖200!");
}
else if(redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1){
System.out.println("恭喜中奖10!");
}
else if(redCount == 2 && blueCount == 1 || redCount == 1 && blueCount == 1 || redCount == 0 && blueCount == 1){
System.out.println("恭喜中奖5!");
}
else {
System.out.println("谢谢参与");
}
}
//创建数组
public static int[] creatArr(){
int[] arr = new int[7];
Random r = new Random();
for (int i = 0; i < 6; i++) {
int randomRed = r.nextInt(33)+1;
if(!isExist(arr,randomRed)){
arr[i] = randomRed;
}
}
int randomBlue = r.nextInt(16)+1;
arr[arr.length - 1] = randomBlue;
return arr;
}
//用户输入号码
public static int[] userInput(){
Scanner sc = new Scanner(System.in);
int[] arr = new int[7];
for(int i = 0;i < 6;){
System.out.println("请输入第" + (i+1) +"个红球号码");
int inputRed = sc.nextInt();
if(inputRed >= 1 && inputRed <= 33){
if(!isExist(arr,inputRed)){
arr[i] = inputRed;
i++;
}
else{
System.out.println("输入重复,请重新输入");
}
}
else{
System.out.println("输入错误,请重新输入");
}
}
while (true) {
System.out.println("请输入蓝球号码");
int inputBlue = sc.nextInt();
if(inputBlue >= 1 && inputBlue <=16){
arr[arr.length-1] = inputBlue;
break;
}
else {
System.out.println("输入错误,请重新输入");
}
}
return arr;
}
//判断数字是否在数组中出现过
public static boolean isExist(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == number)return true;
}
return false;
}
}
//二维数组
package me.JavaStudy;
public class twoArray {
public static void main(String[] args) {
//二维数组
int[][] arr = {
{1,2,3},
{4,5,6,7},
{8,9,10},
};
//二维数组的遍历
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
二维数组的动态初始化
- 格式: 数据类型[][] 数组名 = new 数据类型[m][n];
类和对象
- 类(设计图):是对象共同特征的描述.
- 对象:是真实存在的具体东西.
public class 类名
1.成员变量(属性)
2.成员方法(行为)
类名 对象名 = new 类名();
- 用来描述一类事物的类,叫做Javabean类-不写main方法
- 编写main方法的类,叫做测试类
封装
对象代表什么,就得封装对应的数据,并提供数据对应的行为
比如 人关门 是 门的行为
package me.JavaStudy;
public class GirlFriend {
//private是一个权限修饰符
//可以修饰成员属性和方法
//被private修饰的成员只能在本类中访问
private int age;
//赋值
public void setAge(int a){
if(a >= 18 && a <= 50){
age = a;
}
else {
System.out.println("数据不合法");
}
}
//获取
public int getAge(){
return age;
}
}
package Test1;
public class GirlFriend {
private int age;
public void setAge(int age){
this.age = age;
}
}
package Test1;
public class Student {
private int age;
private String name;
//默认构造
public Student(){
System.out.println("默认构造");
}
//有参构造
public Student(int age,String name){
this.age = age;
this.name = name;
System.out.println("有参构造");
}
}
快捷键:alt + fn + insert //自动生成get和set和构造函数
线性表的链式表示
链表包括:单链表,双链表,循环链表
带头结点 头指针->头节点->首元节点
不带头指针 头指针 -> 首元结点
*链表的特点:
1. 结点在存储器的位置是任意的,即逻辑上相邻的数据在物理上不一定相邻
2. 访问时只能通过头指针进入链表,并通过每个结点的指针域一次向后顺序扫描其余节点,所以寻找第一个结点但和最后一个结点所花费的时间不一样.
顺序表->随机存取
链表 ->顺序存取
#include<iostream>
using namespace std;
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAXSIZE 100 //线性表存储空间的初始分配量
//Status 是函数的类型,其值是函数结果状态代码
typedef int Status;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//建立链表
Status InitList_L(LinkList &L){
L = new LNode;
L->next = NULL;
return OK;
}
//判断链表是否为空
int ListEmpty(LinkList &L){
if(L->next == NULL)return 0;
else return 1;
}
//销毁链表
Status DestoryList_L(LinkList &L){
LNode *p;
while(L){
p = L;
L = L->next;
delete p;
}
return OK;
}
Status DeleteList_L(LinkList &L){
LNode *p = L->next;
LNode *q;
while(p){
q = p->next;
delete p;
p = q;
}
L->next = NULL;
return OK;
}
//计算链表的长度
int ListLength_L(LinkList &L){
LNode *p = L->next;
int count = 0;
while(p){
p = p->next;
count++;
}
return count;
}
//取值
Status GetElem_L(LinkList L,int i,ElemType &e){
LNode *p = L->next;
int j = 0;
while(p && j < i){
p = p->next;
j++;
}
if(!p || j > i)return ERROR;
e = p->data;
return OK;
}
//查找
LNode* LocateElem_L(LinkList L,ElemType e){
LNode *p;
p = L->next;
while(p){
if(p->data){
return p;
}
p = p->next;
}
return p;
/*
while(p && p->data != e){
p = p->next;
}
return p;
*/
}
//将数据元素插入到pos位置前
Status ListInsert_L(LinkList &L,int pos,ElemType e){
int i = 1;
LNode *p = L;
while(p && i < pos){
p = p->next;
i++;
}
LNode* newl = new LNode;
newl->data = e;
p->next = newl;
newl->next = p->next;
return OK;
}
//将线性表L中第i个数据元素删除
Status ListDelete_L(LinkList &L,int i,ElemType &e){
LNode* p = L;
int j = 0;
while(!(p->next) && j < i-1){
p = p->next;
++j;
}
if(!(p->next)||j>i-1)return ERROR;
LNode* q = new LNode;
q = p->next;
p->next = q->next;
e = q->data;
delete q;
return OK;
}
//头插法建立新链表
void CreateList_H(LinkList &L,int n){
L = new LNode;
L->next = NULL;
for(int i = 0; i < n; i++){
LNode *p = new LNode;
cin>>p->data;
p->next = L->next;
L->next = p;
}
}
//尾插法建立新链表
void CreatList_P(LinkList &L,int n){
L = new LNode;
L->next = NULL;
LNode* r = L;
for(int i = 0; i < n; i++){
LNode* p = new LNode;
cin>>p->data;
p->next = NULL;
r->next = p;
r = p;
}
}
int main(){
return 0;
}
循环链表:是一种头尾相连的链表
- 优点 :从表中任意结点出发均可找到表中其他结点
注意:表的操作常常是在表的首尾位置进行
尾指针表示单循环链表:a1 = R->next->next
an = R
单链表,循环链表,和双向链表的时间效率比较
存储密度:是指结点数据本身所占的存储量和整个节点结构中所占的存储量之比即:
存储密度 = 结点数据本身所占的空间/结点所占用的空间总量.
*链式存储结构的优点:
* 结点空间可以动态申请和释放。
* 数据元素的逻辑次序靠结点的指针来表示,插入和删除时，不需要移动数据元素。
- 链式存储结构的缺点
顺序表和链表的比较
//合并链表
void MergeList(LinkList &La,LinkList &Lb,LinkList&Lc){
LNode* pa = La->next;
LNode* pb = Lb->next;
LNode* pc = Lc = La;
while(pa && pb){
if(pa->data >= pb->data){
pc->next = pb;
pc = pb;
pb = pb->next;
}
else {
pc->next = pa;
pc = pa;
pa = pa->next;
}
}
pc->next = pa ? pa : pb;
}
栈和队列
- 栈和队列是两种常见的,重要的数据结构
- 栈和队列是限定插入和删除只能在表的"端点"进行的线性表.
栈--后进先出-子弹夹
队列--先进先出
