精华内容
下载资源
问答
  • pulltorefreshView扩展了ListView多布局,显示不同的布局展示用处很...该异常如下: 这是怎么回事呢? 具体代码如下:public static final int TYPE_MALE = 1; public static final int TYPE_FEMALE = 2; @Override

    996.icu

    pulltorefreshView扩展了ListView多布局,显示不同的布局展示用处很多 ,但在对getItemViewType处理的时候容易下标出错。
    该异常如下:

    这里写图片描述

    这是怎么回事呢?
    具体代码如下:

    public static final int TYPE_MALE = 1;
        public static final int TYPE_FEMALE = 2;
       @Override
        public int getViewTypeCount() {
            return 2;
        }
        @Override
        public int getItemViewType(int position) {
            String sex = list.get(position).getSex();
            switch (sex) {
                case "男":
                    return TYPE_MALE;
                case "女":
                    return TYPE_FEMALE;
                default:
                    return TYPE_MALE;
            }
        }
    

    对代码做修正其他地方,无需修改就可以正常运行了

    public static final int TYPE_MALE = 0;
        public static final int TYPE_FEMALE = 1;
            @Override
        public int getViewTypeCount() {
            return 2;
        }
        @Override
        public int getItemViewType(int position) {
            String sex = list.get(position).getSex();
            switch (sex) {
                case "男":
                    return TYPE_MALE;
                case "女":
                    return TYPE_FEMALE;
                default:
                    return TYPE_MALE;
            }
        }
    
    

    listView的多布局展示中getView方法最重要,再次贴出该段代码

     @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View ret = null;
            ViewHolder1 holder1 = null;
            ViewHolder2 holder2 = null;
            int type = getItemViewType(position);
    
            //进行复用,如果convertView为空,根据type生成对应布局
            if (convertView != null) {
                ret = convertView;
            } else {
                switch (type) {
                    case TYPE_MALE:
                        ret = LayoutInflater.from(context).inflate(R.layout.item_man, null);
                        break;
                    case TYPE_FEMALE:
                        ret = LayoutInflater.from(context).inflate(R.layout.item_femal, null);
                        break;
                }
            }
            //实例化ViewHolder ,findViewById
            switch (type) {
                case TYPE_MALE:
                    holder1 = (ViewHolder1) ret.getTag();
                    if (holder1 == null) {
                        holder1 = new ViewHolder1();
                        holder1.man_image = ((ImageView) ret.findViewById(R.id.man_image));
                        holder1.man_name = ((TextView) ret.findViewById(R.id.man_name));
                        holder1.sex = ((TextView) ret.findViewById(R.id.sex));
                        ret.setTag(holder1);
                    }
                    break;
                case TYPE_FEMALE:
                    holder2 = (ViewHolder2) ret.getTag();
                    if (holder2 == null) {
                        holder2 = new ViewHolder2();
                        holder2.female_image_one = ((ImageView) ret.findViewById(R.id.femal_image_one));
                        holder2.female_image_two = ((ImageView) ret.findViewById(R.id.femal_image_two));
                        holder2.female_name = ((TextView) ret.findViewById(R.id.femal_name));
                        holder2.sex = ((TextView) ret.findViewById(R.id.sex));
                        ret.setTag(holder2);
                    }
                    break;
            }
            //进行赋值
            switch (type) {
                case TYPE_MALE:
                    holder1.man_image.setImageResource(list.get(position).getImage());
                    holder1.man_name.setText(list.get(position).getName());
                    holder1.sex.setText(list.get(position).getSex());
                    break;
                case TYPE_FEMALE:
                    holder2.female_image_one.setImageResource(list.get(position).getImage());
                    holder2.female_image_two.setImageResource(list.get(position).getImage());
                    holder2.female_name.setText(list.get(position).getName());
                    holder2.sex.setText(list.get(position).getSex());
                    break;
            }
            return ret;
        }
    

    转载自http://blog.csdn.net/soft_po/article/details/51590257

    /**
    * 在对pulltorefreshView进行事件处理的时候,要对position进行处理;i
    * pulltorefreshView是对listView进行扩展,pulltorefeshView下拉的view就占据了listView中的一个position ,通过addHeaderView进行设置,
    * 因此在通过position获取node的时候要进行position-1处理。(此处在adapter中多布局处理的时候,还要根据实际情况对position进行"-2/-3"的处理)
    * @author xu_click
    */

    展开全文
  • 异常数组、常用类

    2020-07-03 22:24:05
    怎么让我 们写的程序做出合理的处理,不至于崩溃是我们关注的核心。 异常机制就是当程序出现错误,程序如何安全退出的 机制。 所谓错误是指在程序运行的过程中发生的一些例外事件(如:除0,数组下标越界,所要读取...

    异常、数组、常用类

    第一节 异常

    1. 异常的概念

    异常**(Exception)** 即例外,程序没有按自己预想的结果运行出来,出现了非正常情况,即“程序得病了”。怎么让我 们写的程序做出合理的处理,不至于崩溃是我们关注的核心。 异常机制就是当程序出现错误,程序如何安全退出的 机制。

    所谓错误是指在程序运行的过程中发生的一些例外事件(如:除0,数组下标越界,所要读取的文件不存在)。

    Java异常类是Java提供的用于处理程序中错误的一种机制。设计良好的程序应该在异常发生时提供处理这些错误的 方法,使得程序不会因为异常的发生而阻断或发生不可预见的结果。

    Java程序的执行过程中如出现例外事件,可以生成一个异常类对象,该异常对象封装了例外事件的信息并将被提交 给Java运行时系统,这个过程称为**抛出****( throw )**异常

    当Java运行时系统接收到异常对象时,会寻找能处理这一异常的代码并把当前异常对象交给其处理,这一过程称为 **捕获(**catch)异常。

    2. 异常的分类

    JDK中定义了很多异常类,这些类对应了各种各样可能出现的例外事件。我开着车走在路上,一头猪冲在路中间, 我刹车,这叫一个 异常。我开着车在路上,发动机坏了,我停车,这叫错误

    Error**:称为错误,由Java虚拟机生成并抛出,包括动态链接失败、虚拟机错误等,程序对其不做处理。Error 类层 次描述了 Java 运行时系统内部错误和资源耗尽错误。这类错误是我们无法控制的,同时也是非常罕见的错误。所 以在编程中,不去处理这类错误。Error 表明系统 JVM 已经处于不可恢复的崩溃状态中。我们不需要管他。 如:写 代码时突然断电,或者内存溢出。

    Exception:所有异常的父类,其子类对应了各种各样可能出现的异常事件,一般需要用户显示地声明或捕获。

    Runtime Exception

    Runtime Exception类是 Exception 类的子类,叫做运行时异常,Java 中的所有运行时异常都会直接或者间接地继 承自 RuntimeException 类。

    这一类特殊的异常,如被0除、数组下标超范围等,其产生比较频繁,处理麻烦,如果显示的声明或捕获将会对程 序可读性可运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理);我 们可以通过程序的健壮性来处理,不推荐使用异常处理机制来处理。

    例如:

    NullPointerException: 当程序访问只有引用没有对象的成员属性或成员方法。怎么处理?

    ArithmeticException: 除数为 0ClassCastException:多态时类型转换错误

    ArrayIndexOutOfBoundsException: 访问的元素下表超过数组长度

    NumberFormatException: 数字格式异常!

    CheckException

    Java 中凡是继承自 Exception,而不继承自 RuntimeException 类的异常都是非运行时异常,也叫检查时异常

    如:IOException。 必须要对其进行处理,否则无法通过编译。这类异常的产生不是程序本身的问题,通常由外界因 素造成的。 为了预防这些异常产生时,造成程序的中断或得到不正确的结果,Java 要求编写可能产生这类异常的 程序代码时,一定要去做异常的处理。

    3. 异常处理

    异常产生

    之所以出现异常,是因为内部抛出了异常对象,这个异常对象的产生分为系统内部产生,或程序员手动抛出异常。

    异常捕获try catch finally

    对于编译(非运行)时异常( checked exception ),必须要对其进行处理,否则无法通过编译。处理方式有两种:

    异常捕获

    异常处理

    try代码段包含可能产生例外的代码

    **try代码段后跟有一个或多个catch代码段

    每个catch代码段声明其能处理的一种特定类型的异常并提供处理的方法

    当异常发生时,程序会中止当前的流程,根据获取异常的类型去执行相应的catch代码段一个 try 后面可以跟多个catch,但不管多少个, 最多只会有一个catch 块被执行。

    finally段的代码无论是否发生异常都有执行

    try语句

    try{…}语句制定了一段代码,该段代码就是一次捕获并处理意外的范围。

    在执行过程中,该段代码可能会产生并抛出一种或几种类型的异常对象,它后面的catch语句要分别对这些异常做 相应的处理。

    如果没有意外产生,所有的catch代码段都被略过不执行。

    catch语句

    在catch语句块中是对异常进行处理的代码,每个try语句块可以伴随一个或多个catch语句,用于处理可能产生的 不同类型的异常对象。在catch中声明的异常对象封装了异常事件发生的信息,在catch语句块中可以使用这个对象的一些方法获取这些信

    息。

    例如:

    getMessage()方法,用来得到有关异常事件的信息

    printStackTrace()方法,用来跟踪异常事件发生时执行堆栈的内容

    finally语句

    finally语句为异常处理提供一个统一的出口,使得在控制流程转到程序的其它部分以前,能够对程序的状态作统一 的管理。无论try所制定的程序块中是否抛出异常,fifinally所指定的代码都要被执行。

    通常在fifinally语句中可以进行资源的清除工作,如:

    关闭打开的文件

    删除临时文件

    向外声明(抛出)异常throws

    在产生异常的方法声明后面写上 throws 某一个 Exception 类型,如 throws Exception,将异常抛出到外面一层 去

    异常与重写声明

    子类声明的异常范围不能超出父类的异常范围

    4.使用自定义的异常

    概念

    所谓自定义异常,通常就是定义一个类,去继承 Exception 类或者它的子类。因为异常必须直接或者间接地继承 自 Exception 类。通常情况下,会直接继承自 Exception 类,一般不会继承某个运行时的异常类。

    步骤使用自定义异常一般有如下步骤:

    1、 通过继承java.lang.Exception类声明自己的异常类

    2、 在方法适当的位置生成自定义异常的实例,并用throw语句抛出

    3、 在方法声明部分用throws语句声明该方法可能抛出的异常

    第二节 数组

    1. 数组概述和特点

    概念

    所谓数组(Array),就是相同数据类型的元素按一定顺序排列的集合,就是把有限个类型相同的变量用一个名字命 名,然后用编号区分他们的变量的集合,这个名字称为数组名,编号称为下标。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。数组是在程序设计中,为了处理方便,把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组 “[]”。

    数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。每个数组元素可以通过一个下标来访问它们.

    特点

    1. 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
    2. 其元素必须是相同类型**,不允许出现混合类型。
    3. 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
    4. 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是 对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

    2.一维数组创建和初始化

    声明数组

    type*[] arr_name; //(推荐使用这中方式) 
    
    type arr_name[];
    

    1.声明的时候并没有实例化任何对象,只有在实例化数组对象时,JVM才分配空间,这时才与长度有关。因此, 声明数组时不能指定其长度(数 组中元素的个数),例如: int a[5]; //非法

    1. 声明一个数组的时候并没有数组被真正的创建。

    2. 构造一个数组,必须指定长度。

    构建数组

    方式一

    type[] 变量名 = new type[数组中元素的个数];

    如: int[] a = new int[10];

    数组名,也即引用a,指向数组元素的首地址。

    方式二

    type变量名[] = new type[]{元素列表};

    如: int[] a = new int[]{1,2,3};

    可以省略为: type变量名[] ={元素列表}; 仅在声明和赋值时可以省略

    内存结构

    创建基本类型一维数组示例

    type*[] arr_name; //(推荐使用这中方式)

    type arr_name[];创建引用类型一维数组示例

    3.数组的遍历

    普通for

    for(int 索引=0;索引<长度;索引++){ 
    数组[索引] =}
    

    增强for

    for(元素类型 局部变量:数组){ 
    
    	局部变量 
    
    }
    

    4.数组的界限

    1、必须开辟空间才能使用否则出现 java.lang.NullPointerException

    2、索引的范围 [0,length) 否则出现

    java.lang.ArrayIndexOutOfBoundsException

    3、长度:[0,∞)

    0 表示空数组,确定了存放的数据类型,该数组不能直接使用,如果使用

    java.lang.ArrayIndexOutOfBoundsException

    -1:编译通过,运行错误,如果使用

    java.lang.NegativeArraySizeException

    5. 数组方法

    数组长度

    Java中的每个数组都有一个名为length的属性,表示数组的长度。 length属性是public fifinal int的,即length是只 读的。数组长度一旦确定,就不能改变大小。

    equals()

    Arrays.equals()

    public static void main(String[] args){ 
    
    	int[] a = {1, 2, 3};  
    
    	int[] b = {1, 2, 3};  
    
    	System.out.println(Arrays.equals(a,b));  
    
    }
    

    Arrays.sort():排序

    public static void main(String[] args){ 
    
    	int[] arr ={11,2,8,3,4,5,6,7,9,9,10,12,13}; 
    
    	System.out.println(Arrays.toString(arr));  
    
    	Arrays.sort(arr);  
    
    	System.out.println(Arrays.toString(arr));  
    
    }
    

    Arrays.binarySearch(数组,元素):二分法查找

    public static void main(String[] args){ 
    
    	int[] arr ={11,2,8,3,4,5,6,7,9,9,10,12,13};  
    
    	int idx =Arrays.binarySearch(arr, 9);  
    
    	System.out.println(idx);  
    
    }
    

    数组拷贝

    Arrays. copyOf(源数组,长度)

    void System.arraycopy(源数组,源起始索引,目标数组,目标起始索引,长度)

    6.二维数组

    多维数组可以看成以数组为元素的数组

    int[][] arr = {{},{},{}}; 
    
    int[][] arr1 = new int[3][]; // 必须给定高维 
    
    int[][] arr2 = new int[2][3];
    

    第三节 常用类

    1. 字符串相关类

    String

    不可变的字符序列

    StringBuffffer

    可变字符序列,并且线程安全,但是效率低

    StringBuilder

    可变字符序列,线程 不安全,但是效率高 (一般用他!)

    String

    由于使用特别多,所以有特殊快捷的创建方式通过双引号 “” 直接创建对象

    构造方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jFLFPiP8-1593786208878)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593784526612.png)]

    常用方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e0SaI5xc-1593786208881)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593784557664.png)]

    StringBuffffer和StringBuilder

    这两个类使用方式类似。一般用于做字符串拼接,删除,替换,反转,截取,插入等。

    通过查看源码,认识StringBuffffer和StringBuilder的构造方式,以及与String的转换方式

    2.包装类

    JAVA并不是纯面向对象的语言。Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象 的。但是我们在实际使用中经常需要将基本数据转化成对象,便于操作。比如:集合的操作中。例如使用Map对象要操作put()方法时,需要传入的参数是对象而不是基本数据类型。为了解决这个不足,在设计类时为每个基本数据 类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。包装类均位于java.lang包

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HTPkZKUI-1593786208883)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593784711645.png)]

    在这八个类名中,除了Integer和Character类以后,其它六个类的类名和基本数据类型一直,只是类名的第一个字母大写即可。

    八种基本数据类型对应的包装类。

    什么是自动装箱和自动拆箱,代码怎么写?
    ​		Integer x = 100; // x里面并不是保存100,保存的是100这个对象的内存地址。
    ​		Integer y = 100;
    ​		System.out.println(x == y); // true
    
    ​		Integer x = 128;
    ​		Integer y = 128;
    ​		System.out.println(x == y); // false
    
    Integer类常用方法。
    		Integer.valueOf()
    		Integer.parseInt("123")
    		Integer.parseInt("中文") : NumberFormatException
    
    Integer String int三种类型互相转换。
    

    对于包装类说,这些类的用途主要包含两种:

    a、作为和基本数据类型对应的类类型存在,方便涉及到对象的操作。

    b、包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法(这些操作方法的作用是在基本类型数据、包装类对象、字符串之间提供转化)。

    包装类和基本类型之间存在自动装箱和自动拆箱操作,所以可以互相方便地切换。

    3.日期类

    作为与我们息息相关的日期,在开发中也是很常见的。在程序中,日期的存储也是个数字,是个长整型的数字。0 代表1970年1月1日 00:00:00,而我们处于东八区,所以为1970年1月1日 08:00:0 ,往前推,负数表示之前的时间,往后算正数表示之后的时间。

    而在日常中,我们表示日期是使用字符串表示,如 1970年1月1日 08:15 1970/01/01 08:15 1970-01-01 08:15 等等,因此就涉及到 如何将长整型数与字符串互转的问题,这也是学习的重点。

    pre8常用日期相关类

    常见方法
    System系统类 currentTimeMillis(): 当前时间
    Date 日期类 new Date() :当前时间 new Date(指定时间):指定时间 getTime(): 获取时间 setTime(指定时间):设置指定时间
    SimpleDateFormat格式器 new SimpleDateFormat(模板) format() : 格式化为字符串 parse():转成日期

    (1) 当前时间

    //当前毫秒数 
    
    long timeNum =System.currentTimeMillis(); 
    
    System.out.println(timeNum); 
    
    //当前日期 
    
    Date nowDate =new Date(); 
    
    System.out.println(date); 
    

    (2) Date

    //0 时间点 东八区 1970年1月1日 08:00:0 
    
    Date date =new Date(0L); 
    
    System.out.println(date); 
    
    //指定一个时间 
    
    Date myDate =new Date(189712329239L); 
    
    System.out.println(myDate); 
    
    System.out.println(myDate.getTime()); //获取长整型数字 
    
    //修改时间 
    
    myDate.setTime(0L); 
    
    System.out.println(myDate);
    

    (3) SimpleDateFormat

    日期格式化,在日期格式化的过程中,会用到模板,这个在api中有详细说明

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jusiC6RP-1593786208886)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593785269826.png)]

    字符串的表示形式与日期互换,使用日期转换器SimpleDateFormat ,代码如下:

    public static void main(String[] args) throws ParseException { 
    
    Date myDate2 =new Date(0L); 
    
    //字符串的形式 
    
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
    
    //转字符串 
    
    String dateStr =dateFormat.format(myDate2); 
    
    System.out.println(dateStr); 
    
    //转成日期 
    
    myDate = dateFormat.parse("2020-02-25 11:16:30"); //这里有异常 
    
    System.out.println(myDate.getTime()); 
    }
    

    注意parse()存在 的异常 ParseException

    4.Math类

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QkRWtBmJ-1593786208889)(C:\Users\dell\AppData\Roaming\Typora\typora-user-images\1593785862009.png)]

    5.File类

    File 代表文件和目录路径名的抽象表示形式
    File 类的常见构造方法:public File(String pathname)
    以 pathname 为路径创建 File 对象,如果 pathname 是相对路径,则默认的当前路径在系 统属性 user.dir 中存
    储。 File 的静态属性 separator 存储了当前系统的路径分隔符。
    常见的方法

    public boolean canRead()  
    public boolean canWrite()  
    public boolean exists()   
    public boolean isDirectory()  
    public boolean isFile()   
    public boolean isHidden()  
    public long lastModified() 
    public long length()
    public String getName()   
    public String getPath()
    

    代码示例

    import java.io.File;
    /** * 程序 -->文件 需要建立联系 * 抽象为 File 类
    
    - - 1、文件夹 与文件 抽象-->File * 2、分割符: *  路径分隔符: ; pathSeparator  *  目录分隔符: \  /  separator  * 
        静态常量:
    - - 1、构建 File
        File(String pathname) 
    - File(File parent, String child) 
    - File(String parent, String child) 
      *
      */
      public class FileDemo01 {
      /**
    - @param args
      */
      public static void main(String[] args) {
       System.out.println(File.pathSeparator);
       System.out.println(File.separator);
       //绝对路径 与文件建立联系
       File src = new File("E:\\test\\03.gif");
       src = new File("E:/test/03.gif");
       src = new File("E:"+File.separator+"test"+File.separator+"03.gif");
       System.out.println(src.exists());
        //相对路径
       File src2 = new File("E:/test","03.gif");
       src2 = new File(new File("E:/test"),"03.gif");
       System.out.println(src.exists());
      }
      }
      import java.io.File;
      import java.io.FilenameFilter;
      import java.io.IOException;
      /** * 1、创建对象 new File(完整路径)  -->绝对路径 new File(上级路径,本名); -->相对路径  new File(上级抽象表示形
      式, 本名) 2、方法 1)区分目录 or 文件
      isFile() isDirectory() 2)获取路径 名称
      getPath()
      getAbsolutePath()
      getName()  3)判断文件是否存在
      exists()  4)创建文件
      createNewFile()  5)创建目录 mkdir() -->创建一层,确保父路径存在,如果父路径不存在,不能创建 mkdirs() -->父路径不
      存在,全部创建 6)列表
      listFiles() 7)删除文件
      delete() 
      *
      *
      */
      public class FileDemo02 {
      public static void main(String[] args) throws IOException {
       File src2 = new File("E:/test","03.gif");  boolean flag =src2.isFile(); //是否为文件
       flag =src2.isDirectory();
       System.out.println(flag);  //获取文件名称或路径
       String name = src2.getName();
       System.out.println(name);
       String path = src2.getPath();
       path = src2.getAbsolutePath();
       System.out.println(path);
        //文件是否存在
       flag = src2.exists();  if(!flag){ //不存在创建
       src2.createNewFile();
      }  //创建目录
       src2 = new File("E:/test/test2/test3");  src2.mkdir(); //确保父路径存在,才能创建  src2.mkdirs();// 如果父路径不存在,
      则创建
        //列出当前文件夹的子目录
       src2 = new File("E:/xp/20130401");  if(src2.isDirectory()){ //目录才有子目录
       File[] subFiles = src2.listFiles(new FilenameFilter(){
        @Override
        public boolean accept(File dir, String name) {
        /*
        System.out.println(name);
        if(name.contains("xls")){
      return true;
        }*/
    
      return !new File(dir,name).isDirectory();
     }
     });
     for(File temp:subFiles){
      System.out.println(temp);
     }
    }
     //delete() 
     src2 = new File("E:/test","03.gif");
     boolean flag2 =src2.delete();
     System.out.println(flag2);
    }
    }
    

    通过 File 对象创建空文件或目录(在该对象所指的文件或目录不存在的情况下)。

    public boolean createNewFile()throws IOException  
    public boolean delete() 
    public boolean mkdir()
    mkdirs()
    /** *递归打印文件夹 */ 
    public static void printName(File src){ 
      if(null ==src){  
        return; 
     } 
      System.out.println(src.getPath());  
      if(src.isDirectory()){  
        for(File sub:src.listFiles()){  
          printName(sub);  
       } 
     } 
    }
    

    s){
    System.out.println(temp);
    }
    }
    //delete()
    src2 = new File(“E:/test”,“03.gif”);
    boolean flag2 =src2.delete();
    System.out.println(flag2);
    }
    }

    
    通过 File 对象创建空文件或目录(在该对象所指的文件或目录不存在的情况下)。
    
    ```java
    public boolean createNewFile()throws IOException  
    public boolean delete() 
    public boolean mkdir()
    mkdirs()
    /** *递归打印文件夹 */ 
    public static void printName(File src){ 
      if(null ==src){  
        return; 
     } 
      System.out.println(src.getPath());  
      if(src.isDirectory()){  
        for(File sub:src.listFiles()){  
          printName(sub);  
       } 
     } 
    }
    
    展开全文
  • 如果越界操作就会得到一个RuntimeException异常。2.数组只能保存特定类型。数组可以保存原生数据类型,集合则不能。集合不以具体的类型来处理对象,它们将所有对象都按Object类型处理,集合中存放的是对象的引用而...

    一.关于数组的特点

    1.在Java中,无论使用数组或集合,都有边界检查。如果越界操作就会得到一个RuntimeException异常。

    2.数组只能保存特定类型。数组可以保存原生数据类型,集合则不能。集合不以具体的类型来处理对象,它们将所有对象都按Object类型处理,集合中存放的是对象的引用而不是对象本身。

    3.集合类只能保存对象的引用。而数组既可以创建为直接保存原生数据类型,也可以保存对象的引用。在集合中可以使用包装类(Wrapper Class),如Integer、Double等来实现保存原生数据类型值。

    例码:

    int a = 10;

    Integer integer = new Integer(a);

    int b = integer.intValue();

    System.out.println(a = b);

    4.对象数组和原生数据类型数组在使用上几乎是相同的;唯一的区别是对象数组保存的是引用,原生数据类型数组保存原生数据类型的值。

    二.数组的正确使用

    如果需要存储大量的数据,例如如果需要读取100个数,那么就需要定义100个变量,显然重复写100次代码,是没有太大意义的。如何解决这个问题,Java语言提供了数组(array)的数据结构,是一个容器可以存储相同数据类型的元素,可以将100个数存储到数组中。这时候数组就有很大的帮助了~

    1.数组的好处

    存数据和不存数据有什么区别吗?数组的最大好处就是能都给存储进来的元素自动进行编号.注意编号是从0开始。方便操作这些数据。

    例如 学生的编号,使用学号就可以找到对应的学生。

    2.数组的格式

    格式一:

    元素类型[]数组名 = new元素类型[元素个数或数组长度];

    示例:

    int[] arr = new int[5];

    arr[0] = 1;

    arr[1] = 2;

    格式二:

    元素类型[]数组名 = new元素类型[]{元素,元素,……};

    int[] arr = new int[]{3,5,1,7};

    int[] arr = {3,5,1,7};

    注意:给数组分配空间时,必须指定数组能够存储的元素个数来确定数组大小。创建数组之后不能修改数组的大小。可以使用length属性获取数组的大小。

    3.声明数组变量

    为了使用数组必须在程序中声明数组,并指定数组的元素类型

    =左半部分:

    先写左边明确了元素类型 是int ,容器使用数组,那么如何来标识数组?.那么用一个特殊的符号[]中括号来表示。想要使用数组是需要给数组起一个名字的,那么我们在这里给这个数组起名字为x .接着跟上等号。

    代码体现:

    int [] x

    注意:int x[] 也是一种创建数组的格式。推荐使用int [] x的形式声明数组。

    4.创建数组

    =右半部分:

    要使用一个新的关键字.叫做new。new用来在内存中产生一个容器实体,数据要存储是需要有空间的,存储很多数据的空间用new操作符来开辟,new int[3];这个3是元素的个数。右边这部分就是在内存中定义了一个真实存在的数组,能存储3个元素。

    new int[3] 做了两件事情,首先使用new int[3]创建了一个数组,然后把这个数组的引用赋值给数组变量x。

    int [] x=new int[3];

    x 是什么类型?

    任何一个变量都得有自己的数据类型。注意这个x 不是int类型的 。int代表的是容器里边元素的类型。那么x是数组类型的。

    数组是一种单独的数据类型。数据类型分为2大派,分为基本数据类型和引用数据类型。 第二大派是引用数据类型。那么大家现在已经接触到了引用数据类型三种当中的一种。就是数组类型[] 中括号就代表数组。

    int[] arr = new int[5];在内存中发生了什么?

    内存任何一个程序,运行的时候都需要在内存中开辟空间.int[] arr = new int[5];这个程序在内存中是什么样?这就涉及到了java虚拟机在执行程序时所开辟的空间,那么java开辟启动了多少空间呢?继续学习java的内存结构。

    5.数组初始化

    方式一:不使用运算符new

    int[]arr = { 1, 2, 3, 4, 5 };

    方式二:使用运算符new

    int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

    int[] arr3=new int[3];

    arr3[0]=1;

    arr3[1]=5;

    arr3[2]=6;

    如果数组初始化中不使用运算符new。需要注意:下列写法是错误的。

    int[] arr;

    arr={1,2,3,4,5};

    此时初始化数组,必须将声明,创建,初始化都放在一条语句中个,分开会产生语法错误。

    所以只能如下写:

    int[] arr={1,2,3,4,5};

    6.数组的遍历

    public static void main(String[] args) {

    int[] x = { 1, 2, 3 };

    for (int y = 0; y < 3; y++) {

    System.out.println(x[y]);

    // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

    } // 那么这就是数组的第一个常见操作.遍历

    }

    数组中有一个属性可以获取到数组中元素的个数,也就是数组的长度.数组名.length

    public static void main(String[] args) {

    int[] x = { 1, 2, 3 };

    for (int y = 0; y < x.length; y++) {

    System.out.println(x[y]);

    // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

    } // 那么这就是数组的第一个常见操作.遍历

    }

    7.数组的常见异常

    一数组角标越界异常:,注意:数组的角标从0开始。

    public static void main(String[] args) {

    int[] x = { 1, 2, 3 };

    System.out.println(x[3]);

    //java.lang.ArrayIndexOutOfBoundsException

    }

    二 空指针异常:

    public static void main(String[] args) {

    int[] x = { 1, 2, 3 };

    x = null;

    System.out.println(x[1]);

    // java.lang.NullPointerException

    }

    数组:

    什么时候使用数组:当元素较多时为了方便操作这些数组,会先进行来临时存储,所使用的容器就是数组。

    特点:

    数组长度是固定的。

    8.数组的常见操作

    一:案例:

    一个数组取出最大值

    /*定义一个获取最大值的功能:

    1、确定结果 :返回值类型 int

    2、未知内容:要获取哪个数组的最大值没有确定,则是数组没有确定

    思路:

    1、定义一个变量,记录住数组的比较大的元素。

    2、遍历整个数组,让数组的每一个元素都和该变量进行对比即可。

    3、当变量遇到比它大的元素,则让该变量记录该元素的值,当循环结束时,最大   值产生了

    */

    public static int getMax(int[] arr)

    {

    //定义变量记录较大的值,初始化为数组中的任意一个元素。

    int max = arr[0];

    for(int x=1; x

    {

    if(arr[x]>max)

    max = arr[x];

    }

    return max;

    }

    二:直接排序

    案例二:使用直接排序对数组进行排序:

    /*

    选择排序。

    以一个角标的元素和其他元素进行比较。

    在内循环第一次结束,最值出现的头角标位置上。

    */

    public static void selectSort(int[] arr)

    {

    for(int x=0; x

    {

    for(int y=x+1; y

    //都用x角标上的元素和下一个元素进行比较。

    {

    if(arr[x]>arr[y])

    {

    int temp = arr[x];

    arr[x] = arr[y];

    arr[y] = temp;

    }

    }

    }

    }

    三:冒泡排序

    /*

    冒泡排序。

    比较方式:相邻两个元素进行比较。如果满足条件就进行位置置换。

    原理:内循环结束一次,最值出现在尾角标位置。

    */

    public static void bubbleSort(int[] arr)

    {

    for(int x=0; x

    {

    for(int y=0; y

    //-1:避免角标越界。

    {

    if(arr[y]>arr[y+1])

    {

    int temp = arr[y];

    arr[y] = arr[y+1];

    arr[y+1] = temp;

    }

    }

    }

    }

    四:折半查找(二分法)

    /*

    为了提高查找效率,可使用折半查找的方式,注意:这种查找只对有序的数组有效。

    这种方式也成为二分查找法。

    */

    public static int halfSeach(int[] arr,int key)

    {

    int min,mid,max;

    min = 0;

    max = arr.length-1;

    mid = (max+min)/2;

    while(arr[mid]!=key)

    {

    if(key>arr[mid])

    min = mid + 1;

    else if(key

    max = mid - 1;

    if(min>max)

    return -1;

    mid = (max+min)/2;

    }

    return mid;

    }

    五:数组翻转

    /*

    反转其实就是头角标和尾角标的元素进行位置的置换,

    然后在让头角标自增。尾角标自减。

    当头角标

    */

    public static void reverseArray(int[] arr)

    {

    for(int start=0,end=arr.length-1; start

    {

    swap(arr,start,end);

    }

    }

    //对数组的元素进行位置的置换。

    public static void swap(int[] arr,int a,int b)

    {

    int temp = arr[a];

    arr[a] = arr[b];

    arr[b] = temp;

    }

    11.二维数组

    Arrays的使用

    Java 数组的详解

    遍历: toString()    将数组的元素以字符串的形式返回

    排序: sort()        将数组按照升序排列

    查找: binarySearch()在指定数组中查找指定元素,返回元素的索引,如果没有找到返回(-插入点-1) 注意:使用查找的功能的时候,数组一定要先排序。

    二维数组:

    吸烟:

    没钱       零买   1根                 一个变量

    稍微有钱   一包   一维数组      20根变量

    很有钱     一条   10包(二维数组)        二维数组

    二维数组:实质就是存储是一维数组。

    数组定义:

    数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

    Java 数组的详解

    疑问: 为什么a.length = 3, a[0].length = 4?

    Java 数组的详解

    数组的初始化:

    静态初始化:

    int [][] a = new int[][]{ {12,34,45,89},{34,56,78,10},{1,3,6,4} };

    动态初始化:

    Java 数组的详解

    二维数组常见的操作:

    1. 遍历二维数组

    2. 对二维数组求和

    class Demo3

    {

    // 定义一个遍历二维数组的功能函数

    public static void printArr2( int [][] a ){

    // 1. 拆开二维数组

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

    {

    // 2. 拆开一维数组获取数据

    for ( int j = 0 ; j < a[i].length ; j++ )

    {

    System.out.print( a[i][j]+" ," );

    }

    }

    }

    // 定义一个函数计算二维数组中的元素的累加和

    public static long getSum( int [][] a ){

    // 0. 定义一个结果变量

    long sum = 0L;

    // 1. 拆开二维数组

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

    {

    // 2. 拆开一维数组获取数据

    for ( int j = 0 ; j < a[i].length ; j++ )

    {

    sum+=a[i][j];

    }

    }

    return sum;

    }

    // 统计二维数组中元素的个数

    public static int getDataCount( int [][] a ){

    // 0. 记录元素个数

    int count = 0;

    // 1. 拆开二维数组

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

    {

    // 2. 拆开一维数组获取数据

    for ( int j = 0 ; j < a[i].length ; j++ )

    {

    count++;

    }

    }

    return count;

    }

    public static void main(String[] args)

    {

    int [][] a = new int[][]{ {23,4,5},{2},{4,5,78,56,90} };

    printArr2( a );

    System.out.println();

    System.out.println("累加和是: "+getSum( a ) );

    System.out.println("统计元素个数: "+getDataCount( a ) );

    System.out.println("Hello World!");

    }

    }

    以上就是所有关于java数组的话题,如你所见,java数组是一种非常强大的数据结构。

    展开全文
  • 空指针异常(NullPointerException)String str=null;...数组下标越界(ArrayIndexOutOfBoundsException)int[] ary={1,2,3}for{int i=0;i<=3;i++){System.out.println(ary[i]);}类型转换异常(ClassCast...

    空指针异常(NullPointerException)

    String str=null;

    System.out.println(str.length());

    数组下标越界(ArrayIndexOutOfBoundsException)

    int[] ary={1,2,3}

    for{int i=0;i<=3;i++){

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

    }

    类型转换异常(ClassCastException)

    class Animal{

    }

    class Dog extends Animal{

    }

    class Cat extends Animal{

    }

    public class Test{

    public static void main(String[] args){

    Animal a1=new Dog();

    Animal a2=new Cat();

    Dog d1=(Dog)a1;

    Dog d2=(Dog)a2;

    算数异常(ArithmeticException)

    int one=12;

    int two=0;

    System.out.println(one/two);

    运行时异常会由java虚拟机自动抛出,并自动捕获。

    运行时出现异常大部分情况说明代码本身有问题,应该从逻辑上去改进代码。

    展开全文
  • 异常:程序在运行过程中...程序运行时一旦出现异常,将会导致程序立即终止,异常之后的代码将无法继续执行,所以需要对异常进行处理 常见异常异常 含义 发生时机 ArithmeticException 算术异常 除数为0 ...
  • 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存、数组下标越界等。 在Java的异常处理机制中,引进零很多用来描述和处理异常的类,称为异常类。异常类定义中包含了该类...
  • 异常处理

    2021-01-09 23:51:55
    怎么处理代码运行中的异常 1.Java程序执行过程中所发生的异常分为两类 1.1 Error:Java虚拟机无法解决的严重问题。如JVM系统内部错误、资源严重情况。如StackOverflowError(栈溢出)、oom(堆溢出)、一般不编写针对性...
  • 前言在编程中异常报错是不可避免的...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Jav...
  • Java中的异常处理前言在编程中异常报错是不可避免的。...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安...
  • 前言在编程中异常报错是不可避免的...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Jav...
  • 前言在编程中异常报错是不可避免的。...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的...
  • 在编程中异常报错是不可避免的。...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Java...
  • 前言在编程中异常报错是不可避免的...​异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Java...
  • 前言在编程中异常报错是不可避免的...​ 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Jav...
  • 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Java的异常处理机制中,引进了很多用来...
  • java异常处理

    2021-01-20 23:17:17
    怎么处理? 程序可以从错误中恢复吗?恢复不了就崩溃么? 一、异常 意外产生和处理过程概述: 运行时有许多因素引起出错,硬件失败,除法溢出,数组下标越界。 出错的位置都在方法Method里 出错后方法生成一个...
  • 在编程中异常报错是不可避免的。...​异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。异常机制本质就是当程序出现错误,程序安全退出的机制。在Java的...
  • System命名空间下的类,用来表示数组下标越界引发的异常 说明:写了一个随机抽题的方法,用于随机抽取access数据库题目,开始时能够正常抽题,正常显示,大概随机抽取20-30题左右,出现上述异常。然后vs2008...
  • Java-异常处理详解

    2021-03-06 19:09:59
    1.Java异常:在程序运行过程中...所以我们要学习怎么处理异常,以使程序可以继续运行或者优雅地终止. 2.异常处理的规范:异常应该从方法抛出,而由方法的调用者来捕获和处理异常,以至于调用者决定是否终止程序. ...
  • 第一节 异常1. 异常的概念​ 异常(Exception) 即例外,程序没有按...​ 所谓错误是指该程序运行的过程中发生的一些例外事件(如:除0,数组下标越界,所要读取的文件不存在)。​ Java异常类是Java提供的用于处理程...
  • 语法错误、编译时错误语义错误、逻辑错误、运行时错误数组下标越界,c,c++不检查,需要程序员控制。1、注意:这里说的异常是运行期错误,不包括编译期错误。2、try尝试运行,catch捕获并处理,finally无论出错不...
  •  当JavaScript程序在运行中发生了诸如数组索引越界、类型不匹配或者语法错误时,JavaScript解释器就会引发例外处理。ECMAScript定义了六种类型的错误,除此之外,我们可以使用Error对象和throw语句来创建并引发...
  • 题目:实现如下功能,接收一个yyyymmdd形式的整数(例如...那么怎么实现异常处理呢?显然主要是控制输入的位数(用for实现)、控制月份和日期不越界。为了简单起见,默认每个月最大天数为31天。可以分别对月份和日...
  • 2周前版本号 #2前面学院君介绍了 Go 语言通过 error 接口统一进行错误处理,但这些错误都是我们在编写代码时就已经预见并返回的,对于某些运行时错误,比如数组越界、除数为0、空指针引用,这些 Go 语言是怎么处理的...
  • 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等,英文是:Exception,意思是例外。遇到这些例外情况,或者叫异常,我们怎么让写的程序做出合理的处理,...
  • 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等,英文是:Exception,意思是例外。遇到这些例外情况,或者叫异常,我们怎么让写的程序做出合理的处理,...
  • 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等,英文是:Exception,意思是例外。遇到这些例外情况,或者叫异常,我们怎么让写的程序做出合理的处理,...

空空如也

空空如也

1 2 3
收藏数 50
精华内容 20
关键字:

数组越界异常怎么处理