java初学者日志_数组

最新推荐文章于 2024-06-20 19:01:05 发布
最新推荐文章于 2024-06-20 19:01:05 发布
阅读量255 收藏
点赞数 1
分类专栏： java日记 文章标签： java object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_start_/article/details/114031108
版权

数组的基本特点：
1.数组长度是确定的，一旦被创建，就不能改变
2.数组元素类型必须相同
3.数组类型可以是任何数据类型，包括基本类型和引用类型
4.数组变量属于引用类型，数组也是对象
数组是对象，那么数组中的元素就是对象的属性，所以当创建完数组还未开始赋值的时候，数组中元素的值为各个类型的默认初始值

public class test_01 {
    public static void main(String[] args) {
        int[] s;
        //动态赋值
      /*  int[] j=new j[3];
        j[0]=1;
        j[1]=10;
        j[2]=11;
        */
        s=new int[10];
        for (int i=0;i<10;i++){
            //s[i]=2*i+1;//数组是对象，数组中的元素就是对象的属性
            System.out.print(s[i]+"\t");
        }
    }
}

在这里插入图片描述

import java.util.Arrays;

class MAN{
    private int id;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString(){
        return "id:"+id+",age:" +age;
    }
    public MAN(){};
    public MAN(int id, int age){
        this.id=id;
        this.age=age;
    }
}
public class test_2 {
    public static void main(String[] args) {
        MAN[] mans={
                new MAN(1,11),
                new MAN(2,22),
                new MAN(3,33),
                new MAN(4,44),
                new MAN(5,55)
        };
        //System.out.println(mans);
        for(int i=0;i<mans.length;i++){
            MAN man=mans[i];
        System.out.println(man);
        }
        //增强for循环（读取元素的值）
        for(MAN man:mans){
            System.out.print(man+"\t");
        }
    }
 }

Arrays类测试

import java.lang.reflect.Array;
import java.util.Arrays;
public class gongjv {
    public static void main(String[] args) {
        int[] a={100,10,60,8,200,300,400};
        int[] b={1,2,33,15,4,6,8,99,38,76,56};
        int[] c={10,2,33,15,4,6,8,99,38,76,56};
        //输出数组的内容,此处Arrays.toString是Arrays的静态方法
        System.out.println(Arrays.toString(a));
        //从小到大进行排序.
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //使用二分查找法,查找之前必须先对数组排序
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        System.out.println("该元素的索引："+Arrays.binarySearch(b,8));
        //对数组进行填充
        System.out.println("填充前的数组C:"+Arrays.toString(c));
        Arrays.fill(c,2,5,20);
        System.out.println("填充后的数组C："+Arrays.toString(c));
    }
}

数组的拷贝

public class test_zhengqiang {
    public static void main(String[] args) {
        String[] ss={"aa","bb","cc","dd","ee","ff"};
        String[] gg=new String[6];
        //数组拷贝
        System.arraycopy(ss,1,gg,0,3);
        for(int i=0;i<gg.length;i++) {
            System.out.println(gg[i]);
        }
        //增强for循环专门读取数组或集合中所有元素
        for(String temp:ss){
            System.out.println(temp);
        }
    }
}

在这里插入图片描述
二维数组

public class test_erwei {
    public static void main(String[] args) {
        //二维数组的声明
        int[][] a=new int[3][];
        a[0]=new int[3];
        a[1]=new int[4];
        a[2]=new int[5];
        int[][] b={{1,2,3,4},{5,6,7},{8,9}};
        System.out.println(b[1][2]);
    }
}

在这里插入图片描述
使用二维数组存放表格数据

import java.util.Arrays;

public class test_liebiao {
    public static void main(String[] args) {
        Object[] a1={1001,"张三",18,"学生","2019-10"};
        Object[] a2={1002,"李四",17,"班长","2019-11"};
        Object[] a3={1003,"王五",19,"学习委员","2019-12"};
        Object[][] temp=new Object[3][];
        temp[0]=a1;
        temp[1]=a2;
        temp[2]=a3;
        for(int i=0;i<temp.length;i++) {
            for(int j=0;j<temp[i].length;j++) {
                System.out.print(temp[i][j]+"\t");
            }
            System.out.println("");
        }
        //System.out.println(Arrays.toString(temp[0]));
    }
}

import java.util.Arrays;
class Emp{
    private int id;
    private String name;
    private int age;
    private String job;
    private String hire;

    public Emp(){}
    public Emp(int id, String name, int age, String job, String hire) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.hire=hire;
    }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getAge() { return age+"岁"; }
    public void setAge(int age) { this.age = age; }
    public String getJob() { return job; }
    public void setJob(String job) { this.job = job; }
    public String getHire() { return hire; }
    public void setHire(String hire) { this.hire = hire; }
    public String toString(){
        return getId()+"\t"+getName()+"\t"+getAge()+"\t"+getJob()+"\t"+getHire();
    }
}
public class test_javabean {
    public static void main(String[] args) {
        Emp emp1=new Emp(1001,"张三",12,"程序员","2019-10");
        Emp emp2=new Emp(1002,"李四",17,"设计师","2019-11");
        Emp emp3=new Emp(1003,"王五",19,"产品经理","2019-12");
        //Emp[] emps={emp1,emp2,emp3}
        Emp[] emps=new Emp[3];
        emps[0]=emp1;
        emps[1]=emp2;
        emps[2]=emp3;
        for(int i=0;i<emps.length;i++) {
            System.out.println(emps[i].getId()+" "+emps[i].getName());
        }
        for(int i=0;i<emps.length;i++) {
            //for(int j=0;j<emps[i])
            System.out.println(emps[i]);
        }
    }
}

小练习
嵌套循环未能实现

class shangpin{
    private int id;
    private String name;
    private String xinghao;
    private double jiage;
    private double zhekou;

    public shangpin(){}
    public shangpin(int id, String name, String xinghao, double jiage, double zhekou) {
        this.id = id;
        this.name = name;
        this.xinghao = xinghao;
        this.jiage = jiage;
        this.zhekou = zhekou;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getXinghao() {
        return xinghao;
    }

    public void setXinghao(String xinghao) {
        this.xinghao = xinghao;
    }

    public double getJiage() {
        return jiage;
    }

    public void setJiage(double jiage) {
        this.jiage = jiage;
    }

    public double getZhekou() {
        return zhekou;
    }

    public void setZhekou(double zhekou) {
        this.zhekou = zhekou;
    }
    public String toString(){
        return getId()+"\t"+getName()+"\t"+getXinghao()+"\t"+getJiage()+"\t"+getZhekou();
    }

}

public class test_job {
    public static void main(String[] args) {
        shangpin sp1=new shangpin(1,"鼠标","BZ_001",99.21,0.9);
        shangpin sp2=new shangpin(2,"玩偶","WO_035",401.1,0.79);
        shangpin sp3=new shangpin(3,"书  ","BK_024",30.1,0.87);
        shangpin sp4=new shangpin(4,"西装","XZ_011",499.21,0.89);
        shangpin sp5=new shangpin(5,"手机","SJ_003",1999.21,0.79);
        shangpin[] sps=new shangpin[5];
        sps[0]=sp1;
        sps[1]=sp2;
        sps[2]=sp3;
        sps[3]=sp4;
        sps[4]=sp5;
        System.out.println(sps[1].getId());
       /* for(int i=0;i<sps.length;i++){
            System.out.println(sps[i]);
        }*/
        for(int i=0;i<sps.length;i++){
            if(sps[i].getJiage()*sps[i].getZhekou()>100.0) {
                System.out.println(sps[i]);
                System.out.println("商品最终售价为："+sps[i].getJiage()*sps[i].getZhekou());
            }/*else{
                System.out.println(sps[i]);
            }*/
        }
    }
}

若一个数组中有多个数据类型，该如何比较？

可以使用comparable接口，

package com.shuzu;
import java.util.Arrays;
public class TestComparable {
    public static void main(String[] args) {
        Man2[] manss={
                new Man2(3,"a"),
                new Man2(6,"b"),
                new Man2(1,"c")
        };
        Arrays.sort(manss);
        System.out.println(Arrays.toString(manss));
    }


class Man2 implements Comparable
{
    int age;
    int id;
    String name;
    public Man2(int age,String name){
        super();
        this.age=age;
        this.name=name;
    }
    public String toString(){
        return this.name;
    }
    public int compaerTO(Object o){
        Man2 man=(Man2) o;
        if(this.age<man.age){
            return -1;
        }
        if(this.age>man.age){
            return 1;
        }
        return 0;
    }
}

二分查找

import java.util.Arrays;
public class test_erfen {
    public static void main(String[] args) {
        int[] ef={2,5,66,61,54,16,3,1,14,25,106,84,63,654,44,35,1654,6,456,4};
        int srarchWord = 14;
        Arrays.sort(ef);
        System.out.println(Arrays.toString(ef));
        System.out.println(srarchWord+"元素的索引："+binarySearch(ef,srarchWord));
    }
    public static int binarySearch(int[] ef,int srarchWord){
        int low=0;
        int high=ef.length-1;
        while (low<=high){
            int middle =(low+high)/2;
            if(srarchWord==ef[middle]){
                return middle;
            }
            if(srarchWord<ef[middle]){
                high=middle-1;
            }
            if(srarchWord>ef[middle]){
                low=middle+1;
            }
        }
        return -1;
    }
}

冒泡排序

public class test_maopao {
    public static void main(String[] args) {
        int[] mp={3,5,4,91,51,2,12,335,15,994,442};
        bubbleSort(mp);
        System.out.println(Arrays.toString(mp));

    }
    public static void bubbleSort(int[] mp){
        int temp=0;
        for(int i=0;i<mp.length;i++){
            for(int j=0;j<mp.length-1;j++){
                if(mp[j]>mp[j+1]){
                    temp=mp[j+1];
                    mp[j+1]=mp[j];
                    mp[j]=temp;
                }
            }
        }
    }
}
星空辰梦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数据流接收_JAVA IO分析二：字节数组流、基本数据&对象类型的数据流、打印流...
weixin_36024106的博客
02-21 336
importjava.io.DataOutputStream ;importjava.io.File ;importjava.io.FileOutputStream ;public classDataOutputStreamDemo{public static void main(String args[]) throws Exception{ //所有异常抛出DataOutputStrea...
Java初学者日志_集合_List
dream_start_的博客
03-06 184
1.集合与数组存储数据概述: 集合，数组都是对多个数据进行存储操作的结构，简称Java 容器。 说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(. txt,. jpg,.avi,数据库中) 2.数组存储的特点: 一旦初始化以后，其长度就确定了。 数组- -旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。 比如: String[] arr;int[] arr1;object[] arr2;* 3.数组存储的弊端: * :旦初始化以后，其长度就不可修改。 数组中提供
java中打印输出数组
weixin_30783629的博客
04-13 147
import java.util.Arrays; public class ArrayDemo { public static void main(String[] args) { int size = 4; // 数组大小 int[] myList = new int[size];// 定义数组 myList[0] = 5;...
关于数组的表示
nbxzkok的专栏
02-28 717
#这就是个数组方括号表示[]，索引一样从0开始 ，-1表示最后一个开始-2就是倒数第二个 array_full=['aaa','bbb','ccc'] print(array_full[0]) print(array_full[-1]) #输出 aaa ccc...
java 日志文件或控制台如何输出一个数组对象或自定义对象
bird_tp的博客
10-24 5772
输出数组对象：Arrays.asList方法 例如：params = new Object[]{new Date(beginTime),new Date(endTime),node.getMn()}; LOG.info("参数为："+Arrays.asList(params)); 输出自定义对象：JSONObject.fromObject 例如： 导包：import ...
java基础知识0717
JwdD594的博客
07-18 485
###05.01_Java语言基础(数组概述和定义格式说明)(了解) * A:为什么要有数组(容器)     * 为了存储同种数据类型的多个值 * B:数组概念     * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。     * 数组既可以存储基本数据类型，也可以存储引用数据类型。 * C:数组定义格式     数据类型[] 数组名 = new 数据类型[数组
Java初学者日志_集合_Map
dream_start_的博客
03-10 174
package com.jihe.java1.Map; import javax.swing.*; import java.util.*; /*-----Map接口:双列集合，用来存储一对(key-value)，一对的数据(高中函数：y=f(x),一个key只能对应一个value，一个value可以对应多个一个key) /-----HashMap:作为Map的主要实现类线程不安全，效率高，存储null和value -------LinkedHashMap:保证在
JAVA上百实例源码以及开源项目
01-03
　基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
Java学习路线图.pdf
09-08
Java学习路线图涵盖了从基础到高级的全面知识体系，适合初学者和进阶者进行系统学习。以下是对各个知识点的详细解释： 1. **Java基础**： - **Java概述与环境搭建**：理解Java编程语言的基本概念，安装JDK，配置...
Java-0基础开发手册.pdf
09-08
《Java-0基础开发手册》是针对初学者和有经验的Java开发者的一份综合指南，旨在提高开发效率和软件质量。手册由阿里巴巴技术团队编写，结合了社区开发者的意见，涵盖了从基础编程到高级特性的多个方面。手册内容丰富...
JAVA上百实例源码以及开源项目源代码
12-11
2个目标文件 摘要:Java源码,网络相关,UDP 基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式...
Java程序员们最常犯的10个错误.docx
12-16
在Java编程中，程序员们常常会遇到一些常见的错误，这些错误可能在初学者和经验丰富的开发者之间都有所体现。本文将探讨Java程序员们最常犯的10个错误，并给出相应的纠正方法，这对于准备Java面试或者日常开发工作都...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 691
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 240
Java爬虫Jsoup
Java面试八股之简述JVM内存结构
最新发布
u012151345的博客
06-20 721
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 224
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 962
GeoServerBasePage 登录
Java中的Continue语句及其示例
Muhtar_的博客
06-20 141
Continue语句主要用于循环内部。每当在循环中遇到它时，控件都会直接跳到循环的开头进行下一次迭代，跳过当前迭代中循环体中语句的执行。当您希望继续循环，但不希望循环体中的其余语句（在continue语句之后）为该特定迭代执行时，这一点尤其有用。和你在这里看到的一样。我们将计数器值从10迭代到0，当计数器值为7时，循环跳过print语句并开始while循环的下一次迭代。示例：在While循环中使用continue。do-Wile循环中continue的示例。Java中的Continue语句及其示例。
java初学者经典100例
12-04
Java初学者经典100例是一个非常适合Java初学者学习的编程题集。这套题集精选了100个典型的编程问题，通过解决这些问题可以帮助初学者掌握Java的基本语法和常用逻辑。 这套题集主要包括了基本数据类型的使用、条件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值