1.对象数据的处理&2.json数据处理&3.提取网站并计算流量&4.分组TopN&5.MapjoinTest

最新推荐文章于 2020-12-20 16:44:33 发布
最新推荐文章于 2020-12-20 16:44:33 发布
阅读量243 收藏
点赞数
分类专栏： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42796847/article/details/100139128
版权

1.对象数据的处理:

在这里插入图片描述
(1)person类:

package com.mr.day05.test01;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class person implements Writable {

    private String name;

    private int age;

    private int score;

    private String sex;




    public person(String name, int age, int score, String sex) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.sex = sex;
    }


    public person() {

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public void write(DataOutput out) throws IOException {
            out.writeUTF(this.name);
            out.writeInt(this.age);
            out.writeInt(this.score);
            out.writeUTF(this.sex);


    }

    @Override
    public void readFields(DataInput in) throws IOException {

        this.name = in.readUTF();
        this.age = in.readInt();
        this.score = in.readInt();
        this.sex = in.readUTF();

    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", sex='" + sex + '\'' +
                '}';
    }
}

(2)

package com.mr.day05.test01;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class onlymap2object01 {
    public  static   class  map01 extends Mapper<LongWritable, Text, person, NullWritable> {
        person persons;

        @Override
        protected void setup(Context context) throws IOException, InterruptedException {
           persons=new person();
        }

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {





           if (key.get()!=0){
               //String[] vsplit = value.toString().split(" ");
               String vsplits=new String(value.getBytes(),0,value.getLength(),"GBK");
               String[] vsplit= vsplits.split(",");

               if (vsplit.length>=4){
                   persons.setName(vsplit[0]);
                   persons.setAge(Integer.valueOf(vsplit[1]));
                   persons.setScore(Integer.valueOf(vsplit[2]));



                   persons.setSex(vsplit[3]);


                   context.write(persons,NullWritable.get());

               }




           }
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        Configuration conf = new Configuration();
        //conf.set("fs.defaultFS","hdfs://master:9000");

        Job job = Job.getInstance(conf);

        job.setJarByClass(onlymap2object01.class);

        job.setMapperClass(map01.class);


        job.setNumReduceTasks(0);

        //指定map和reduce输出数据的类型
        job.setMapOutputKeyClass(person.class);
        job.setMapOutputValueClass(NullWritable.class);






        FileInputFormat.setInputPaths(job,new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\01-对象数据处理\\input01"));

        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\01-对象数据处理\\output01");


        if (fs.exists(outPath)){
            fs.delete(outPath,true);
        }

        FileOutputFormat.setOutputPath(job,outPath);

        job.submit();
    }

}

结果图:

在这里插入图片描述

2.json数据处理

在这里插入图片描述

package com.mr.day05.test05;

public class Phone {
        private long uid;
        private long phone;

        private String addr;

    public long getUid() {
        return uid;
    }

    public void setUid(long uid) {
        this.uid = uid;
    }

    public long getPhone() {
        return phone;
    }

    public void setPhone(long phone) {
        this.phone = phone;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }


    public Phone(long uid, long phone) {
        this.uid = uid;
        this.phone = phone;
    }

    public Phone() {

    }


    @Override
    public String toString() {
        return "Phone{" +
                "uid=" + uid +
                ", phone=" + phone +
                ", addr='" + addr + '\'' +
                '}';
    }
}


package com.mr.day05.test05;



import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;

import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.codehaus.jackson.map.ObjectMapper;

import java.io.IOException;

public class ReadJson2Object {
    public static class ReadJson2ObjectMapper extends Mapper<LongWritable, Text,Phone, NullWritable> {

        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String line=new String(value.getBytes(),0,value.getLength(),"GBK");
            ObjectMapper objectMapper = new ObjectMapper();
            Phone phone = objectMapper.readValue(line, Phone.class);
            context.write(phone,NullWritable.get());
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        job.setJarByClass(ReadJson2Object.class);

        job.setMapperClass(ReadJson2ObjectMapper.class);

        job.setOutputKeyClass(Phone.class);
        job.setOutputValueClass(NullWritable.class);

        job.setNumReduceTasks(0);

        FileInputFormat.setInputPaths(job,new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\05-json数据处理\\input01"));

        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\05-json数据处理\\output01");
        if (fs.exists(outPath)){
            fs.delete(outPath,true);
        }

        FileOutputFormat.setOutputPath(job,outPath);

        boolean b = job.waitForCompletion(true);
        System.exit(b?0:1);

    }

}
结果图:

在这里插入图片描述

3.提取网站并计算流量

在这里插入图片描述

package com.mr.day05.test02;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class mrtest02 {

    public  static   class  map01 extends Mapper<LongWritable, Text,  Text,Text> {




        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        if (key.get()!=0){
            String[] split1 = value.toString().split("//");
            String[] split2 = split1[1].split("/");
            String[] name = split2[0].split("[.]");
            String[] fls = value.toString().split(" ");
            String fl = fls[2];
            String f2 = fls[3];


            context.write(new Text(name[name.length-2]),new Text(fl+" "+f2));



        }



        }

    }


    public  static  class  reduce01 extends Reducer<Text,Text,Text,Text> {



        protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {



            int ssum=0;
            int xsum=0;
             int zsum=0;
            for (Text unm: values){
                String[] s = unm.toString().split(" ");

                ssum+=Integer.valueOf(s[0]);
                xsum+=Integer.valueOf(s[1]);

            }
            zsum=ssum+xsum;
            context.write(key,new Text(ssum+","+xsum+","+zsum) );

        }






    }


    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        Configuration conf = new Configuration();
        //conf.set("fs.defaultFS","hdfs://master:9000");

        Job job = Job.getInstance(conf);

        job.setJarByClass(mrtest02.class);

        job.setMapperClass(map01.class);
        job.setReducerClass(reduce01.class);


        //指定map和reduce输出数据的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);


        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);



        FileInputFormat.setInputPaths(job,new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\02-提取网站并计算流量\\input01"));

        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\02-提取网站并计算流量\\output01");


        if (fs.exists(outPath)){
            fs.delete(outPath,true);
        }

        FileOutputFormat.setOutputPath(job,outPath);

        job.submit();
    }



}
结果图:

在这里插入图片描述

4.分组TopN:

在这里插入图片描述
(1.Student类继承WritableComparable自定义排序)

package com.mr.day05.test03;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class Student implements WritableComparable<Student> {
    private String name;
    private String subject;
    private double avescore;


    public String getName() {
        return name;
    }

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

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public double getAvescore() {
        return avescore;
    }

    public void setAvescore(double avescore) {
        this.avescore = avescore;
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(this.name);
        dataOutput.writeUTF(this.subject);
        dataOutput.writeDouble(this.avescore);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.name=dataInput.readUTF();
        this.subject=dataInput.readUTF();
        this.avescore=dataInput.readDouble();

    }



    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", subject='" + subject + '\'' +
                ", avescore=" + avescore +
                '}';
    }

    @Override
    public int compareTo(Student s) {
      if (s.getAvescore()==this.getAvescore()){
          return s.getName().compareTo(this.getName());

      }else {
          return s.getAvescore() >this.getAvescore() ? 1:-1;
      }
    }

}

(2.重写Partitioner定义分区)

package com.mr.day05.test03;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Partitioner;

import java.util.*;

public class SubjectPadrtitioner extends Partitioner <Student, NullWritable>{
        // Map<String,Integer>  map=new HashMap<String,Integer>();

        List<String> list=new ArrayList<>();

    @Override
    public int getPartition(Student student, NullWritable nullWritable, int numPartitions) {
       /* map.put("computer",0);
        map.put("english",1);
        map.put("algorithm",2);
        map.put("math",3);
        return map.get(student.getSubject());*/

        System.out.println(student);
       if (list.contains(student.getSubject())){

           return list.indexOf(student.getSubject());

       }else {
           list.add(student.getSubject());
           return list.indexOf(student.getSubject());
       }

    }
}

(3)

package com.mr.day05.test03;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;


import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class mrtest3 {
    public  static   class  map03 extends Mapper<LongWritable, Text,Student, NullWritable> {




        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {


                String[] vsplit = value.toString().split(",");
            if (vsplit.length>=3){
                Student student = new Student();
                Double sum=0.0;
                int num = vsplit.length - 2;
                for (int i=2;i<vsplit.length;i++){

                    sum+=Double.valueOf(vsplit[i]);

                }
               Double avescore=sum/num;


                student.setSubject(vsplit[0]);
                student.setName(vsplit[1]);
                student.setAvescore(avescore);

                //System.out.println(student);
                context.write(student,NullWritable.get());


            }


        }
    }


    public static class Reduce03 extends Reducer<Student,NullWritable,Student, NullWritable> {

        protected void reduce(Student key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
            //System.out.println(key);

           context.write(key,NullWritable.get());
        }



    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        Configuration conf = new Configuration();
        //conf.set("fs.defaultFS","hdfs://master:9000");

        Job job = Job.getInstance(conf);

        job.setJarByClass(mrtest3.class);

        job.setMapperClass(map03.class);
        job.setReducerClass(Reduce03.class);

        job.setNumReduceTasks(4);
        job.setPartitionerClass(SubjectPadrtitioner.class);
        //指定map和reduce输出数据的类型
        job.setMapOutputKeyClass(Student.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setOutputKeyClass(Student.class);
        job.setOutputValueClass(NullWritable.class);



        FileInputFormat.setInputPaths(job,new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\03-分组TopN\\input01"));

        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\03-分组TopN\\output01");


        if (fs.exists(outPath)){
            fs.delete(outPath,true);
        }

        FileOutputFormat.setOutputPath(job,outPath);

        job.submit();
    }

}
结果图:

1
在这里插入图片描述
2
在这里插入图片描述
3
在这里插入图片描述
4
在这里插入图片描述

5.MapjoinTest

小表:
在这里插入图片描述
大表(小连大)
在这里插入图片描述

package com.mr.day05.test04;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class MapJoinTest04 {

    public static class MapJoinTestMapper extends Mapper<LongWritable, Text,Text, NullWritable> {
        Map<String,String> goodsMap = new HashMap<String,String>();

        protected void setup(Context context) throws IOException, InterruptedException {

            BufferedReader br = new BufferedReader(new FileReader("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\04-MapjoinTest\\input01\\小表\\b.txt"));
            String line = "";
            while (StringUtils.isNotBlank(line=br.readLine())){
                String[] split = line.split(",");
                if (split.length>=2){
                    goodsMap.put(split[0],split[1]);
                }
            }
        }

        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String vsplits=new String(value.getBytes(),0,value.getLength(),"GBK");
            String[] split = vsplits.split(",");

            if (split.length>=2){
                String goodInfo = goodsMap.get(split[0]);
                context.write(new Text(split[0]+ ","+split[1]+","+goodInfo),NullWritable.get());
            }
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        job.setJarByClass(MapJoinTest04.class);

        job.setMapperClass(MapJoinTestMapper.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
        job.setNumReduceTasks(0);

//        job.addCacheFile(new URI("hdfs://B01master:9000/join/cache/user.txt"));

        FileInputFormat.setInputPaths(job,new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\04-MapjoinTest\\input01\\inout01"));

        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path("D:\\hadoop\\2019.08.28-05mapReduce的各种案例\\Test\\04-MapjoinTest\\input01\\outout01");
        if (fs.exists(outPath)){
            fs.delete(outPath,true);
        }

        FileOutputFormat.setOutputPath(job,outPath);
        boolean b = job.waitForCompletion(true);
        System.exit(b?0:1);
    }
}

结果图:

在这里插入图片描述

好先生！！！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue.js基于v-for实现批量渲染 Json数组对象列表数据示例
12-29
本文实例讲述了vue.js基于v-for实现批量渲染 Json数组对象列表数据。分享给大家供大家参考，具体如下： Vuejs的出现减轻了对DOM的直接操作，同时它提供的 v-for 渲染列表数据也给我们提供了很大的方便。即使是复杂的...
对象数据的一些简单处理
qq_36655902的博客
01-20 223
package hello; public class PersonData { 　　String Id; 　　String Name; 　　String Type; 　　int Age; 　　public String getId() { 　　　　return Id; 　　} 　　public void setId(String id) { 　　　　Id = id; 　　} 　　　public ...
json输出count如何计算_流计算与消息（一）：通过Flink理解流计算的原理
weixin_27785375的博客
12-20 631
在上节课中，我简单地介绍了消息队列和流计算的相关性。在生产中，消息队列和流计算往往是相互配合，一起来使用的。而流计算也是后端程序员技术栈中非常重要的一项技术。在接下来的两节课中，我们一起通过两个例子来实际演练一下，如何使用消息队列配合流计算框架实现一些常用的流计算任务。这节课，我们一起来基于 Flink 实现一个流计算任务，通过这个例子来感受一下流计算的好处，同时我还会给你讲解流计算框架的实现...
hadoop返回json格式所有监控值
chuanjiaoye5017的博客
10-09 111
datanode监控json格式数据：将http://namenode_ip:50070/dfshealth.jsp的地址替换成http://namenode_ip:50070/jmx resourcemanager监控json格式数据：将http://resourcemanager_ip:...
解析JSON数据
点测营专栏
12-10 738
JSON是很常用的接口返回模式, 例如: http://wthrcdn.etouch.cn/weather_mini?city=北京 通过城市名字获得天气数据 json数据   Python使用JSON的方法: import json json.dumps() #编码，字典转成字符串 json.loads() #解码，字符串转成字典 例子1.将字典转成字符串
json格式传数据（做统计）
weixin_49161209的博客
07-29 1098
json统计数据 一、准备数据与资料 1、统计的html文件 上图是百度上面的一个html文件的效果图 上图是原html代码图，将两个data中的数据写死了（这里注意，必须两个data中的值相对应，不然没有效果） 二、准备两个data中的后台数据 1、data（1）的数据 这里先得到一个（种类名）的集合， 步骤一：创建一个Gson对象， 步骤二：调用Gson中**tojson（）**方法，将集合放入方法中，得到一个json的字符串 步骤三：将字符串传到 html文件中取值 结果入下图： 2、da
javascript中JSON.parse()与eval()解析json的区别
10-22
主要介绍了javascript中JSON.parse()与eval(...解析json的区别,详细描述了json格式数据的操作技巧,并结合实例形式对比分析了使用JSON.parse()与eval()解析json的区别,需要的朋友可以参考下
微信小程序使用wx.request请求服务器json数据并渲染到页面操作示例
10-17
主要介绍了微信小程序使用wx.request请求服务器json数据并渲染到页面操作,结合实例形式分析了微信小程序使用wx.request发送网络请求及返回结果渲染到wxml界面相关操作技巧,需要的朋友可以参考下
学习YUI.Ext第七日-View&JSONView Part Two-一个画室网站的案例
10-31
学习YUI.Ext第七日-View&JSONView Part Two-一个画室网站的案例
json 数据处理 java
u013078295的博客
06-29 231
//数据 [{"name":"field1","value":"文本1"},{"name":"field2","value":"文本2"}] JSONArray jsondata = JSONArray.fromObject(formArray); for (int i = 0; i < jsondata.size(); i++) { JSONObjec
HP-Socket编译-Linux
05-20
HP-Socket编译-Linux
JavaScript_生活在Discord上的开源社区列表.zip
05-20
JavaScript
JavaScript_MultiOn API.zip
05-20
JavaScript
JavaScript_简单和完整的React DOM测试工具，鼓励良好的测试实践.zip
05-20
JavaScript
JavaScript_成为一个Nodejs开发者.zip
05-20
JavaScript
node-v14.5.0-headers.tar.xz
最新发布
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
android手机应用源码带文字的ProgressBar Demo源码.rar
05-20
android手机应用源码带文字的ProgressBar Demo源码.rar
JavaScript_基于Electron和Vuejs的全新跨平台Apple Music体验，从头开始编写，并考虑到性能.zip
05-20
JavaScript
海信LED32EC290N（0000）BOM1通用LED32K220（0000）BOM1生产用软件数据U盘升级文件.zip
05-20
机型：LED32K220 BOM：1 编号：LED32K220（0000）_C010 方案：MST628 版本号：LED32K220_V0000.30.20A.G0809 U盘升级说明： 就是将下载的程序解压到U盘根目录下，即根目录下有个TargetHis文件夹。 U盘采用FAT32格式，将U盘插在上面那个USB口上（若不行则更换另一个usb口）。 升级方式1： 电视开机后，插入U盘，会弹出提示是否升级，确定即可。 升级方式2： 交流开机瞬间不停的按下、松开home键，然后进入自动升级界面。 新贴片的程序第一次升级可能会在升级进度21%的界面卡住，交流断电再上电即可，继续升级。升级完成后自动启动完成即可(首次开机可能要3分钟)。 升级方式3： 插入U盘，电视上电时在串口打印界面按回车键使开机停止在boot界面，键入cu命令，然后回车即可。
json.loads后的数据怎么处理
07-27
引用\[1\]中提到了两种解决json.decoder.JSONDecodeError错误的方法。一种是逐行读取json文件，另一种是修改json文件。逐行读取json文件可以避免一次性加载整个文件导致内存溢出的问题。而修改json文件，比如在文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值