精华内容
下载资源
问答
  • 图片识别项目 是商品包装识别分类

    千次阅读 2021-05-11 18:54:32
    class GoodsDataset(Dataset): def __init__(self, data_dir, mode="train", split_n=0.9, rng_seed=620, transform=None): """ 商品外包装分类任务的Dataset :param data_dir: str, 数据集所在路径 :param ...

    链接:https://pan.baidu.com/s/1zB_v2Ylxs-_tAMfuLSHkrA 
    提取码:1111 
    复制这段内容后打开百度网盘手机App,操作更方便哦

    config.py

    # -*- coding: utf-8 -*-
    """
    # @file name  : config.py
    # @author     : Jnchin https://blog.csdn.net/qq_38237214?spm=1011.2124.3001.5343
    # @date       : 2021-5-6
    # @brief      : 整体项目的配置
    """
    
    DATA_ROOT_DIR = './data/'
    PRE_TRAINING_PTH_PATH = f'./model/alexnet-owt-4df8aa71.pth'
    SAVE_PTH_DIR = f'./model/'
    RESULTS_DIR = f'./results/'
    
    GOODS_LABELID_DICT = {
        '00010990': 0,
        '00010991': 1,
        '00010992': 2,
        '00010993': 3,
        '00010994': 4,
        '00010995': 5,
        '00010996': 6,
        '00010997': 7,
        '00010998': 8,
        '00010999': 9,
        '00011000': 10,
        # '<unknow>': 11,  # 常规来说这里应该再加一个未知位,不过原始数据集中并没有未知分类的数据,因此这里注释掉了,如果未来出现了未知类别的商品,请关闭注释,使本行生效
    }
    
    MAX_EPOCH = 20  # 最多训练轮次
    EARLY_STOP_PATIENCE = 5  # 如果未来几轮模型不再优化就会提前停止训练
    
    BATCH_SIZE = 128  # 批量大小,即每次训练输入128张图片,称为一个Iteration
    
    LR = 0.001  # 初始学习率
    LR_DECAY_STEP = 1  # 可自行修改  多少个Iteration调整学习率一次
    
    LOG_INTERVAL = 2  # 可自行修改 多少Iteration打印一次log
    VAL_INTERVAL = 1  # 可自行修改 多少EPOCH测试一次
    
    NUM_CLASSES = len(GOODS_LABELID_DICT)  # 分类数目,取决于goods_labelId_dict的长度
    

    exp_alexnet.py

    # -*- coding: utf-8 -*-
    https://blog.csdn.net/qq_38237214?spm=1011.2124.3001.5343
    
    import os
    import time
    from tqdm import tqdm
    import numpy as np
    import torch
    import torch.nn as nn
    import torchvision.models as models
    import torch.optim as optim
    from get_data import get_data_loader
    from config import *
    
    class Exp_Alexnet(object):
        def __init__(self):
            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
            self.model = self._build_model()
            self.optimizer, self.scheduler = self._select_optimizer()
            self.criterion = self._select_criterion()
    
        def _build_model(self):
            model = models.alexnet()
            if os.path.exists(PRE_TRAINING_PTH_PATH):
                pretrained_state_dict = torch.load(PRE_TRAINING_PTH_PATH)
                model.load_state_dict(pretrained_state_dict)
            else:
                raise RuntimeError(f"预训练模型未加载!请检查 {PRE_TRAINING_PTH_PATH} 预训练模型文件是否存在!")
    
            num_ftrs = model.classifier._modules["6"].in_features
            model.classifier._modules["6"] = nn.Linear(num_ftrs, NUM_CLASSES)  # 将最后一层的输出数量更改一下
            model.to(self.device)
            return model
    
        def _get_data(self):
            train_loader, valid_loader = get_data_loader()
            return train_loader, valid_loader
    
        def _select_optimizer(self):
            optimizer = optim.SGD(self.model.parameters(), lr=LR, momentum=0.9)  # 选择优化器
            scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=LR_DECAY_STEP, gamma=0.1)  # 设置学习率下降策略
            return optimizer, scheduler
    
        def _select_criterion(self):
            criterion = nn.CrossEntropyLoss()  # 使用交叉熵损失函数
            return criterion
    
        def train(self, train_loader):
            self.model.train()
            total_loss = []
            for data in tqdm(train_loader):
                inputs, labels = data
                inputs, labels = inputs.to(self.device), labels.to(self.device)
                outputs = self.model(inputs)
    
                # backward
                self.optimizer.zero_grad()
                loss = self.criterion(outputs, labels)
                loss.backward()
    
                # update weights
                self.optimizer.step()
    
                total_loss.append(loss.item())
            train_loss = np.mean(total_loss)
            self.scheduler.step()  # 更新学习率
            return train_loss
    
        def vali(self, vali_loader):
            self.model.eval()
            total_loss = []
            correct_val = 0.
            total_val = 0.
            for data in tqdm(vali_loader):
                inputs, labels = data
                inputs, labels = inputs.to(self.device), labels.to(self.device)
    
                bs, ncrops, c, h, w = inputs.size()  # [4, 10, 3, 224, 224]
                outputs = self.model(inputs.view(-1, c, h, w))
                outputs_avg = outputs.view(bs, ncrops, -1).mean(1)  # 将裁剪出的10张图片结果取均值
    
                loss = self.criterion(outputs_avg, labels)
                total_loss.append(loss.item())
    
                _, predicted = torch.max(outputs_avg.data, 1)
                total_val += labels.size(0)
                correct_val += (predicted == labels).squeeze().cpu().sum().numpy()
    
            val_loss = np.mean(total_loss)
            accuracy = correct_val / total_val
            # 一般做机器学习深度学习是不会用准确率作为好坏标准的,我看到你的报告里需要用准确率我就给你用了准确率。
            # 一般用f值 或者 mae, mse, rmse, mape, mspe作为衡量模型的标准,这些都有现成的库,很好写,你自己补上吧。
            return val_loss, accuracy
    
        def trainer(self):
            train_loader, valid_loader = get_data_loader()
            train_loss_log = []
            val_loss_log = []
            accuracy_log = []
            for epoch in range(1, MAX_EPOCH+1):
                print(f'正在第{epoch}轮训练...')
                train_loss = self.train(train_loader)
                train_loss_log.append(train_loss)
                print(f'Train loss is {train_loss}\n')
                print(f'正在评估...')
                val_loss, accuracy = self.vali(valid_loader)
                val_loss_log.append(val_loss)
                accuracy_log.append(accuracy)
                print(f'Validation loss is {val_loss}; Accuracy is {accuracy}\n')
    
                # early stop
                val_min_idx = np.argmin(val_loss_log)
                if len(val_loss_log) - val_min_idx > EARLY_STOP_PATIENCE:
                    print(f'已经达到训练局部最优:\n\
                    轮次:{val_min_idx+1}\n\
                    train loss:{train_loss_log[val_min_idx]}\n\
                    Validation loss:{val_loss_log[val_min_idx]}\n\
                    Accuracy:{accuracy_log[val_min_idx]}\n')
                    break
    
            time_toc = time.time()
            torch.save(self.model.state_dict(), f"{SAVE_PTH_DIR}/{time_toc}.pth")
    
            return train_loss_log, val_loss_log, accuracy_log
    

    get_data.py

    import os
    import random
    from PIL import Image
    import torch
    from torch.utils.data import Dataset, DataLoader
    import torchvision.transforms as transforms
    from config import *
    
    
    class GoodsDataset(Dataset):
        def __init__(self, data_dir, mode="train", split_n=0.9, rng_seed=620, transform=None):
            """
            商品外包装分类任务的Dataset
            :param data_dir: str, 数据集所在路径
            :param transform: torch.transform,数据预处理
            """
            assert mode in ['train', 'valid']
            self.mode = mode
            self.data_dir = data_dir
            self.rng_seed = rng_seed
            self.split_n = split_n
            self.data_info = self._get_img_info()  # data_info存储所有图片路径和标签,在DataLoader中通过index读取样本
            self.transform = transform
    
        def __getitem__(self, index):
            path_img, label = self.data_info[index]
            img = Image.open(path_img).convert('RGB')     # 0~255
    
            if self.transform is not None:
                img = self.transform(img)   # 在这里做transform,转为tensor等等
    
            return img, label
    
        def __len__(self):
            if len(self.data_info) == 0:
                raise Exception("\ndata_dir:{} is a empty dir! Please checkout your path to images!".format(self.data_dir))
            return len(self.data_info)
    
        def _get_img_info(self):
            def str2id(label):
                if label in GOODS_LABELID_DICT.keys():
                    return GOODS_LABELID_DICT[label]
                else:
                    return GOODS_LABELID_DICT['<unknow>']
    
            images_path_list = []
            for root, dirs, files in os.walk(self.data_dir):
                files = list(filter(lambda x: x.endswith('.jpg'), files))
                files = [(os.path.join(root, f), str2id(f.split('-')[0])) for f in files]  # list of (pictue_path, label)
                images_path_list.extend(files)
    
            random.seed(self.rng_seed)
            random.shuffle(images_path_list)
    
            split_idx = int(len(images_path_list) * self.split_n)  # 25000* 0.9 = 22500,做训练集
    
            if self.mode == "train":
                images_path_list = images_path_list[:split_idx]  # 数据集90%训练
            elif self.mode == "valid":
                images_path_list = images_path_list[split_idx:]  # 后面10%做测试集
    
            return images_path_list  # list of (pictue_path, label)
    
    
    def get_data_loader():
        norm_mean = [0.485, 0.456, 0.406]
        norm_std = [0.229, 0.224, 0.225]
    
        train_transform = transforms.Compose([  # 训练方法
            transforms.Resize((256)),  # (256, 256) 区别,只给一个256,这时将短边裁剪到256,长宽比例不变
            transforms.CenterCrop(256),  # 中间截取256*256矩形
            transforms.RandomCrop(224),  # 从256*256随机裁剪224*224  (256-224)*(256-224)种可能
            transforms.RandomHorizontalFlip(p=0.5),  # 随机翻转
            transforms.ToTensor(),
            transforms.Normalize(norm_mean, norm_std),
        ])
    
        normalizes = transforms.Normalize(norm_mean, norm_std)  # 测试方法
        valid_transform = transforms.Compose([
            transforms.Resize((256, 256)),
            transforms.TenCrop(224, vertical_flip=False),  # 会得到10张图片,四个角加中心位置加翻转
            transforms.Lambda(lambda crops: torch.stack([normalizes(transforms.ToTensor()(crop)) for crop in crops])),
            # (b,10,c,h,w)得到一个5维张量
        ])
    
        # 构建MyDataset实例
        train_data = GoodsDataset(data_dir=DATA_ROOT_DIR, mode="train", transform=train_transform)
        valid_data = GoodsDataset(data_dir=DATA_ROOT_DIR, mode="valid", transform=valid_transform)
    
        # 构建DataLoder
        train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
        valid_loader = DataLoader(dataset=valid_data, batch_size=4)
    
        return train_loader, valid_loader
    

     main_alexnet.py

    from matplotlib import pyplot as plt
    import numpy as np
    from exp_alexnet import Exp_Alexnet
    from config import *
    
    if __name__ == "__main__":
    
        # 训练+测试
        exp = Exp_Alexnet()
        train_loss_log, val_loss_log, accuracy_log = exp.trainer()
    
    
        # 可视化
        # =========== 画损失曲线图 ========== #
        def get_min(loss_list):
            return np.argmin(loss_list), np.min(loss_list)
    
        plt.figure(figsize=(10, 7))
        plt.xlabel('EPOCH', fontsize=15)
        plt.ylabel('LOSS', fontsize=15)
        plt.xticks(size=12)
        plt.yticks(size=12)
        plt.plot(train_loss_log, '^-', c='b')
        plt.plot(val_loss_log, 'o-', c='r')
    
        # 画验证loss的最小值点
        min_idx, min_val = get_min(val_loss_log)
        plt.plot(min_idx, min_val, 'ko')  # 画出最小值点
        show_min = 'epoch:%d\nmin loss:%.4f\n\n' % (min_idx, min_val)  # 最小值的描述
        plt.annotate(show_min, xy=(min_idx, min_val), xytext=(min_idx, min_val))  # 写上最小值的描述
    
        plt.legend(['train_loss_log', 'test_loss_log'], fontsize=13)
        plt.savefig('/'.join([RESULTS_DIR, '损失曲线.png']), dpi=1400, bbox_inches='tight')
        plt.show()

    readme

    搭建AlexNet,一般有两种方法:
    1、fine-turning,即直接加载别人已经预训练好的模型,然后根据自己的需要微调。
    (注意在使用时,需要将最后一层全连接层输出由1000改为自己的分类的类别数)
    2、手动改写AlexNet。
    
    这里采用第一种方案,因为比较方便稳定,而且效率高,分类效果好。
    (说人话就是,没事儿别瞎造轮子)
    
    
    # 使用方法:
    1、首先将图片数据放在data目录下,可以乱放,但图片文件名必须是像“00010992-01003.jpg”这种格式
    2、配置好config.py文件后(我已经配置好了),直接运行main_alexnet.py文件即可。

     

     

     

    展开全文
  • Java 八种基本类型包装

    千次阅读 2021-03-09 15:37:10
    基本数据类型 包装类型----------------------------------------------byte java.lang.Byte(父类Number)short java.lang.Short(父类Number)int java.lang.Integer(父类Number)long java.lang.Long(父类Number)...

    基本数据类型   包装类型

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

    byte     java.lang.Byte(父类Number)

    short    java.lang.Short(父类Number)

    int      java.lang.Integer(父类Number)

    long     java.lang.Long(父类Number)

    float     java.lang.Float(父类Number)

    double    java.lang.Double(父类Number)

    boolean  java.lang.Boolean(父类Object)

    char     java.lang.Character(父类Object)

    Number类中有这样的方法:

    byte byteValue() 以 byte 形式返回指定的数值。

    abstract double doubleValue()以 double 形式返回指定的数值。

    abstract float floatValue()以 float 形式返回指定的数值。

    abstract int intValue()以 int 形式返回指定的数值。

    abstract long longValue()以 long 形式返回指定的数值。

    short shortValue()以 short 形式返回指定的数值。

    这些方法其实所有的数字包装类的子类都有,这些方法是负责拆箱的。

    // 基本数据类型 -(转换为)->引用数据类型(装箱)

    Integer i = new Integer(123);

    // 将引用数据类型--(转换为)-> 基本数据类型

    float f = i.floatValue();

    System.out.println(f); //123.0

    // 将引用数据类型--(转换为)-> 基本数据类型(拆箱)

    int retValue = i.intValue();

    System.out.println(retValue); //123

    java5 之后 自动装箱和拆箱

    [-128到127]之间的数据比较特殊

    public class IntegerTest01 {

    public static void main(String[] args) {

    Integer a = 128;

    Integer b = 128;

    System.out.println(a == b); //false

    /*

    java中为了提高程序的执行效率,将[-128到127]之间所有的包装对象提前创建好,

    放到了一个方法区的“整数型常量池”当中了,目的是只要用这个区间的数据不需要

    再new了,直接从整数型常量池当中取出来。

    原理:x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。

    */

    Integer x = 127;

    Integer y = 127;

    // == 永远判断的都是两个对象的内存地址是否相同。

    System.out.println(x == y); //true

    }

    }

    总结一下之前所学的经典异常?

    空指针异常:NullPointerException

    类型转换异常:ClassCastException

    数组下标越界异常:ArrayIndexOutOfBoundsException

    数字格式化异常:NumberFormatException

    //网页上文本框中输入的100实际上是"100"字符串。后台数据库中要求存储100数字,此时java程序需要将"100"转换成100数字。

    int retValue = Integer.parseInt("123"); // String -转换-> int

    //int retValue = Integer.parseInt("中文"); // NumberFormatException

    System.out.println(retValue + 100);

    // valueOf方法作为了解

    //static Integer valueOf(int i)

    // 静态的:int-->Integer

    Integer i1 = Integer.valueOf(100);

    System.out.println(i1);

    // static Integer valueOf(String s)

    // 静态的:String-->Integer

    Integer i2 = Integer.valueOf("100");

    System.out.println(i2);

    三种类型的转换

    9cd91d9721399844e252362dd9691667.png

    展开全文
  • 包装设计实训心得体会包装设计实训心得体会当我们受到启发,对学习和工作生活有了新的看法时,不妨将其写成一篇心得体会,让自己铭记于心,它可以帮助我们了解自己的这段时间的学习、工作生活状态。相信许多人会觉得...

    包装设计实训心得体会

    包装设计实训心得体会

    当我们受到启发,对学习和工作生活有了新的看法时,不妨将其写成一篇心

    得体会,

    让自己铭记于心,

    它可以帮助我们了解自己的这段时间的学习、

    工作生

    活状态。

    相信许多人会觉得心得体会很难写吧,

    以下是小编整理的包装设计实训

    心得体会,希望能够帮助到大家。

    包装设计实训心得体会

    1

    一、

    实习目的:

    一、

    通过对包装设计课程的实训,基本达到:

    二、

    明白包装的功能

    ;

    三、

    懂得包装在市场上发挥的作用

    ;

    四、

    掌握包装设计的基本技巧(含基础理论、思维方式与表现方法)

    ;

    五、

    具有市场的判断能力

    (观察方法)

    反应能力与应变能力

    ;

    六、

    熟知设计方案的

    实现技术。

    七、

    实习时间:

    xx

    10

    26

    八、

    实习地点:

    济南市区各超市卖场

    九、

    实习感受:

    包装设计是为企业产品增加市场机会,掌握包装设计各种技巧,具有包装设

    计对市场的策划能力和左右市场的能力。

    通过对美的概念的探讨,

    建立基本设计

    审美观,探索设计审美基本标准。

    参与包装设计的实习过程能使学生能敏锐的观察现代包装设计的变化与特

    征,并能设计出包装多样性和风格变化,将设计的丰富表现性发挥到最大限度。

    敏锐的观察现代包装设计造型功能的变化与特征,并能设计出多样性的包装容

    器、盒体造型

    ;

    将设计的丰富表现性发挥到最大限度。掌握系列包装的整体设计

    过程,

    能够独立完成从调研到设计以及市场定位,对一个产品从包装形态的选择到

    包装方式的设计以及传达一种包装理念有独立的思考

    ;

    对包装设计认知达到一个

    初级设计师的标准。

    展开全文
  • 包装类(熟悉) 包装类的概念 ​ 通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念...包装类的分类 包装类 对应的基本类型 java.lang.Byte byte java.lang.Short short java.lang.Integer

    java包装类的概念及常用方法详解

    包装类的概念

    ​ 通常情况下基本数据类型的变量不是对象,为了满足万物皆对象的理念就需要对基本数据类型的变 量进行打包封装处理变成对象,而负责将这些变量声明为成员变量进行对象化处理的相关类,叫做包装 类。

     Person p = new Person(); // 对象
     int num = 10; // 非对象
    

    包装类的分类

    包装类对应的基本类型
    java.lang.Bytebyte
    java.lang.Shortshort
    java.lang.Integerint
    java.lang.Longlong
    java.lang.Floafloat
    java.lang.Doubledouble
    java.lang.Booleanboolean
    java.lang.Characterchar

    Integer类的概述

    1. 基本概念

      java.lang.Integer类内部包装了一个int类型的变量作为成员变量,主要用于实现对int类型的包装并 提供int类型到String类之间的转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int MAX_VALUE表示int类型可以描述的最大值,即2^31-1
      public static final int MIN_VALUE表示int类型可以描述的最小值,即-2^31
      public static final int SIZE表示int类型采用二进制补码形式的位数
      public static final int BYTES表示int类型所占的字节个数
      public static final Class TYPE表示int类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Integer(int value)根据参数指定的整数来构造对象(已过时)
      Integer(String s)根据参数指定的字符串来构造对象 (已过时)
      int intValue()获取调用对象中的整数值并返回
      static Integer valueOf(int i)根据参数指定整数值得到Integer类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static int parseInt(String s)将字符串类型转换为int类型并返回
      static String toString(int i)获取参数指定整数的十进制字符串形式
      static String toBinaryString(int i)获取参数指定整数的二进制字符串形式
      static String toHexString(int i)获取参数指定整数的十六进制字符串形式
      static String toOctalString(int i)获取参数指定整数的八进制字符串形式
              System.out.println("将字符串转换为整数是" + i1);
              System.out.println("根据参数获取对应的十进制字符串是十进制" + Integer.toString(200));
              System.out.println("根据参数指定的整数获取对应的二进制数" + Integer.toBinaryString(200));
              System.out.println("根据参数指定的整数获取对应的十六进制数" + Integer.toHexString(200));
              System.out.println("根据参数指定的整数获取对应的八进制数" + Integer.toOctalString(200))
      

    装箱和拆箱的概念

    • 在Java5发布之前使用包装类对象进行运算时,需要较为繁琐的“拆箱”和“装箱”操作;即运算前先将 包装类对象拆分为基本类型数据,运算后再将结果封装成包装类对象。

    • 从Java5开始增加了自动拆箱和自动装箱的功能。

      Integer ia5 = 100; // 直接通过赋值运算符实现自动装箱功能
      int ib = ia5; // 直接通过赋值运算符实现自动拆箱功能
      

    自动装箱池

    • 在Integer类的内部提供了自动装箱池技术,将-128到127之间的整数已经装箱完毕,当程序中使用 该范围之间的整数时,无需装箱直接取用自动装箱池中的对象即可,从而提高效率。

      Integer t1 = 127;
              Integer t2 = 127;
              System.out.println(t1 == t2); // ture
              System.out.println(t1.equals(t2)); // true
              Integer t3 = new Integer(127);
              Integer t4 = new Integer(127);
              System.out.println(t3 == t4); // false
              System.out.println(t3.equals(t4)); // true
      

    Double类的概述

    1. 基本概念

      java.lang.Do uble类型内部包装了一个double类型的变量作为成员变量,主要用于实现对double 类型的包装并提供double类型到String类之间的转换等方法

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int SIZE表示double类型的二进制位数
      public static final int BYTES表示double类型的字节个数
      public static final Class TYPE表示double类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Double(double value)根据参数指定的浮点数据来构造对象(已过时)
      Double(String s)根据参数指定的字符串来构造对象 (已过时)
      double doubleValue()获取调用对象中的浮点数据并返回
      static Double valueOf(double d)根据参数指定浮点数据得到Double类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static double parseDouble(String s)将字符串类型转换为double类型并返回
      boolean isNaN()判断调用对象的数值是否为非数字–> 0/0.0
    4. 扩展:

      java.lang.Number类是个抽象类,是上述类的父类来描述所有类共有的成员。

    Boolean类的概述

    1. 基本概念

      java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量,主要用于实现对 boolean类型的包装并提供boolean类型到String类之间的转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final Boolean FALSE对应基值为false的对象
      public static final Boolean TRUE对应基值为true的对象
      public static final Class TYPE表示boolean类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Boolean(boolean value)根据参数指定的布尔数值来构造对象(已过时)
      Boolean(String s)根据参数指定的字符串来构造对象 (已过时)
      boolean booleanValue()获取调用对象中的布尔数值并返回
      static Boolean valueOf(boolean b)根据参数指定布尔数值得到Boolean类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static boolean parseBoolean(String s)将字符串类型转换为boolean类型并返回
      ((s != null) && s.equalsIgnoreCase(“true”))

    Character类的概述

    1. 基本概念

      java.lang.Character类型内部包装了一个char类型的变量作为成员变量,主要用于实现对char类型 的包装并提供字符类别的判断和转换等方法。

    2. 常用的常量

      常量类型和名称功能介绍
      public static final int SIZE表示char类型的二进制位数
      public static final int BYTES表示char类型的字节个数
      public static final Class TYPE表示char类型的Class实例
    3. 常用的方法

      方法声明功能介绍
      Character(char value)根据参数指定的字符数据来构造对象(已过时)
      char charValue()获取调用对象中的字符数据并返回
      static Character valueOf(char c)根据参数指定字符数据得到Character类型对象
      boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
      String toString()返回描述调用对象数值的字符串形式
      static boolean isUpperCase(char ch)判断参数指定字符是否为大写字符
      static boolean isLowerCase(char ch)判断参数指定字符是否为小写字符
      static boolean isDigit(char ch)判断参数指定字符是否为数字字符
      static char toUpperCase(char ch)将参数指定的字符转换为大写字符
      static char toLowerCase(char ch)将参数指定的字符转换为小写字符

    包装类(Wrapper)的使用总结

    • 基本数据类型转换为对应包装类的方式

      调用包装类的构造方法或静态方法即可

    • 获取包装类对象中基本数据类型变量数值的方式

      调用包装类中的xxxValue方法即可

    • 字符串转换为基本数据类型的方式

      调用包装类中的parseXxx方法即可

    展开全文
  • 首先,由于java中的数据类型int,double等不是对象,所以无法通过向上转型得到Object提供的方法,而像String却可以,原因是String是一个对象而不是一个类型。java提供包装类就是为了解决,基本数据类型因为上述的...
  • 不过我觉得还是分类记忆比较好,一共可以分成四类:整型,浮点型,字符型,逻辑型。 整型按长度排序:byte(-128~127),short(-2^15~2^15-1),int(-2^31~2^31-1),long(-2^63~2^63-1)。 浮点型:float(3.402823e...
  • 基本类型的包装类_Java语言程6.3 基本类型的包装类在Java中,每一种基本数据类型都有一个相应的包装类,这些类都在java.lang包中。8种基本数据类型所对应的包装类是:byte(Byte)、short(Short)、int(Integer)、...
  • 包装包装类是对基础类型数据的包装,让基础数据类型“伪装”成类,具有类的特性,可以进行类的方法操作。一、为什么有包装类?Java 是个面向对象语言,所有的操作都是基于对象。Object 类是 Java 中的对象基础,...
  • 基本类型的包装

    2021-01-06 13:07:06
    1、包装类概念: 将基本数据类型数据组装成引用数据类型数据。 2、包装类作用: String使用数据类型与基本数据类型(byte,short,int,long,...3、包装分类 4、Integer类 (1)API介绍 (2)属性 public class Demo7_In
  • ABC分类法.ppt

    2021-07-25 08:57:36
    1、ABC分类法,基本思想 该方法由意大利经济学家帕雷托首创。该方法的核心思想是在决定一个事物的众多因素中分清主次,识别出少数的但对事 物起决定作用的关键因素和多数的但对事物影响较小的次要因素。,ABC分类法,...
  • 分类 Java的数据类型分为两大类: 基本数据类型 引用类型。 基本数据类型分为四大类型:布尔型、整数型、浮点型、字符型。 布尔型:boolean 整数型:byte,short,int,long 浮点型:float,double 字符型:char ...
  • Java代码块和包装

    2021-03-16 22:27:33
    根据定义方式有三种代码块形式局部代码块定义位置: 在方法体内定义特点: 生命周期即短使用场景: if和for等语句的代码块初始化代码块定义方式: 在类内但方法体外定义,不要static修饰本质: 初始化代码块的执行语句都移...
  • 13.包装类型应用及场景

    千次阅读 2021-06-11 14:55:39
    包装类型作用和应用场景 1、包装类型 Java中提供了8种基本数据类型以及对应的8中包装类型。Java是一种面向对象编程的高级语言,所以包装类型正是为了解决基本数据类型无法面向对象编程所提供的。 基本数据类型 ...
  • 一、包装流定义: 在原始字节流或字符流的基础性,为了提高读写效率进行再次处理的流, 称为包装流/处理流1、缓存字节流 BufferedInputStream 、BufferedOutputStream​ 由于原始流在文件读写时 效率比较低(操作文件...
  • 1. 异常概念_分类1) 什么叫异常?答:异常就是程序运行过程中出现的的不正常现象,它会终端程序的运行。2) 请简述异常的分类?答:2. 异常处理方式之一_捕获异常(1) 捕获异常所使用的关键字有哪些?答:try、catch、...
  • 23.1.包装类的分类 针对八种基本数据类型相应的引用类型-包装类 有了类的特点,就可以调用类中的方法 基本数据类型 包装类 boolean Boolean char Character byte Byte short Short int Integer ...
  • Java基础——包装器类

    2021-03-13 14:49:03
    包装器类我们知道Java的数据类型有基本数据类型和引用数据类型同时基本数据类型又细分,分成四个种类的基本数据类型一共有八种基本数据类型引入Java的八种数据类型只能表示一种数值,但是Java作为面向对象编程,处理...
  • 包装类的equals()方法 错误记录: 定义全局变量使用Integer类型 但是从sql配置类查出的是String类型, 直接使用equals(),明明都是配置1,但是却不等,造成bug 代码示例: public static void main(String[] ...
  • 通过包装类可以让基本数据类型拥有属性、方法,可以对象化交互 包装类与基本数据类型,包装类属于引用类型,故其默认值均是null byte -> Byte short -> Short int -> Integer long -> Long float ...
  • 全球及中国包装机械行业应用规模与发展动态研究报告2022版 HS--HS--HS--HS--HS--HS--HS--HS--HS--HS--HS--HS-- ...1.2 包装机械主要分类 1.2.1 充填机 1.2.2 封口机 1.2.3 裹包机 1.2.4 多功能包装机 1....
  • 全球及中国塑料包装行业...1.1.1 常见包装塑料的种类及特点 1.1.2 塑料包装的主要形式 1.1.3 塑料包装行业在国民经济中的地位 1.2 塑料包装的主要应用领域 1.2.1 食品包装 1.2.2 药品包装 1.2.3 化妆品包装...
  • 这篇文章主要介绍了PHP无限极分类函数的实现方法,结合实例形式详细分析了php实现无限极分类的具体思路、实现代码与相关注意事项,需要的朋友可以参考下本文实例讲述了PHP无限极分类函数的实现方法。分享给大家供大家...
  • 本文实例讲述了PHP无限极分类函数的实现方法。分享给大家供大家参考,具体如下:在开发程序的时候,有时候,我们需要获取所有栏目(包括一级栏目、二级栏目、三级栏目等等),并按照父子关系形成树型结构。可以采取...
  • 文章目录1、数据挖掘的五大流程:1.1获取数据1.2数据预处理1.3 特征工程:1.4 建模,测试模型并预测出结果1.5 上线,验证模型效果2、sklearn中的数据预处理和特征工程3、...3.2 缺失值impute.SimpleImputer3.3 处理分类
  • 前情提要上一篇中,通过一道常见的面试题(即:String、StringBuilder、StringBuffer的区别),引申到Java中基本类型和包装类的相关内容。在这一篇中,我们将解决上一篇中引申出来的问题——基本类型和包装类型到底有...
  • 全球及中国金属包装市场发展状况与竞争趋势研究报告2022...1.1.2 包装分类及常用材料 1.1.3 商品包装的具体要求 1.1.4 金属包装的发展历史 1.2 金属包装容器的概述 1.2.1 金属包装容器的概念 1.2.2 金属包装...
  • 瓦楞纸的种类很多,一般可根据具体需要进行选择。PE缠绕膜是工业用装膜制品,具有拉伸强度高,延伸率大、自粘性好,透明度高等物点。用于手工缠绕膜,也可用于机用缠绕膜,可广泛应用于各种货物的集中包装。为...
  • 本实用新型涉及一种硬币计数分类整理机。背景技术:硬币替代小面额纸币流通为现代生活提供了便利,但硬币分类依然是一项非常有难度的工作。公交系统、银行系统、电信系统、超市等各基层营业网点硬币的收付,整理等...
  • 包装类 - 把基本数据类型封装 byte - Byte short - Short int - Integer long - Long ...构造方法创建 new Integer(“字符串”) --> String 转换成Integer new Integer(int i) 2.装箱和拆箱 装箱:
  • 全球及中国食品包装机械行业发展战略与十四五投资建议报告2022版 ...1.1.1 包装机械的定义与分类 1.1.2 包装机械的简史及作用 1.1.3 包装机械的组成要素及特点 1.1.4 包装机械行业的应用分类 1.2 2019-2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,003
精华内容 34,401
关键字:

包装方法的种类