实习学习记录

已于 2023-09-12 16:50:12 修改
阅读量63 收藏
点赞数
文章标签： 学习 java
于 2023-09-12 16:49:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40733899/article/details/132760696
版权

SQL的Case When

结合sum和count的case when

CASE
when A = B then "未修改"
when A != B then "已修改"
end
sum(
    case 
    when A=B then 1 
    else 0 
    end
)
**简单CASE函数**
COUNT(
    CASE state
    WHEN 1 THEN 1
    ELSE 0 END 
) AS countAmt
 
 
**CASE搜索函数**
COUNT(
    CASE 
    WHEN state = '1' THEN 1
    ELSE 0 END 
) AS countAmt

HttpClient

构建流程：

  1. 创建客户端连接对象CloseableHttpClient httpclient；

  2. 创建URIBuilder uriBuilder对象；

  3. 定义一个list，该list的数据类型是NameValuePair（简单名称值对节点类型），存放Get/Post请求的参数；

  4. 使用uriBuilder.setParameters(list)进行参数拼接;

  5. uriBuilder.build()获取URL；

  6. 创建HttpGet Get/HttpPost Post请求；

  7. 发送Get请求CloseableHttpResponse response=httpclient.execute(httpGet)获取响应模型；

  8. 从响应模型中获取响应实体HttpEntity entity；

  9. 释放连接资源。

public class httpClientUtil {
    //创建客户端连接对象
    private static final CloseableHttpClient httpclient = HttpClients.createDefault();

    /**
     * 发送HttpGet带参请求
     * @param url
     * @param header
     * @return
     */
    public static String sendGet(String url, Map<String, String> header) {
        String result = null;
        CloseableHttpResponse response = null;

        try {
            URIBuilder uriBuilder = new URIBuilder(url);
            //定义了一个list，该list的数据类型是NameValuePair（简单名称值对节点类型）
            //这个代码多处用于Java向url发送Get/Post请求,在发送Get/post请求时用该list来存放参数
            List<NameValuePair> list = new LinkedList<>();
            for(Map.Entry<String,String> entry: header.entrySet()){
                list.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

            }
            uriBuilder.setParameters(list);
            HttpGet httpGet = new HttpGet(uriBuilder.build());
            //设置头部
//            httpGet.setHeader(new BasicHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"));
//            httpGet.setHeader(new BasicHeader("Accept", "text/plain;charset=utf-8"));
            //设置头部
//            for(Map.Entry entry: header.entrySet()){
//                httpGet.setHeader(entry.getKey().toString(),entry.getValue().toString());
//            }
            try {
                response = httpclient.execute(httpGet);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    result = EntityUtils.toString(entity);
                }
            } catch (ParseException | IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    httpclient.close();
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
        return result;
    }
}

SpringBoot单测

  • 单元测试类在测试包test下的路径与类路径Java下的路径最好一致；

  • 如果包目录不一致，则需使用注解@SpringBootTest(classes = xxx.class)指定启动类

Java关键字assert的语法

assert <boolean表达式>

如果<boolean表达式>为true，则程序继续执行。
如果为false，则程序抛出AssertionError，并终止执行。

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

assert <boolean表达式> : <错误信息表达式>

如果<boolean表达式>为true，则程序继续执行。
如果为false，则程序抛出java.lang.AssertionError，并输入<错误信息表达式>。

 Spring提供的Assert类

Assert断言基本上替换传统的if判断，减少业务参数校验的代码行数，提高程序可读性。

使用Assert类的方法，如果检查通过则程序继续往下运行，如果不通过，则中断并抛出异常信息。

Assert.assertEquals(预期值，实际值); //比较实际值与预期值是否相等
Assert.assertNull(变量);  //判断参数是否为Null

MockMvc

  • 在面向对象的程序设计中，模拟对象（英语：mock object）是以可控的方式模拟真实对象行为的假对象。在编程过程中，通常通过模拟一些输入数据，来验证程序是否达到预期结果。
  • MockMvc是由spring-test包提供，实现了对Http请求的模拟，能够直接使用网络的形式，转换到Controller的调用，使得测试速度快、不依赖网络环境。同时提供了一套验证的工具，对于结果的验证十分方便。
  • 接口MockMvcBuilder，提供一个唯一的build方法，用来构造MockMvc。主要有两个实现：StandaloneMockMvcBuilder和DefaultMockMvcBuilder，分别对应两种测试方式，即独立安装和集成Web环境测试（并不会集成真正的web环境，而是通过相应的Mock API进行模拟测试，无须启动服务器）。MockMvcBuilders提供了对应的创建方法standaloneSetup方法和webAppContextSetup方法，在使用时直接调用即可。
// 使用standaloneSetup方法实例化
//注意，如果AA类有@ConfigurationProperties注解，该方式无法获取配置文件相应属性
mockMvc = MockMvcBuilders.standaloneSetup(new AA()).build();

// 使用webAppContextSetup方法实例化
mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();

/**
1. mockMvc.perform：执行一个请求
2. MockMvcRequestBuilders.get("XXX")：构造一个get请求
3. ResultActions.andExpect添加执行完成后的断言
4. ResultActions.andReturn表示执行完成后返回相应的结果
5. ResultActions.andDo添加一个结果处理器，表示要对结果做点什么事情
*/
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get(url)
                      .session(session).contentType("application/json"))
                      .andExpect(status().isOk()).andReturn();

JaCoCo

JaCoCo是一个开源的覆盖率工具，包含了多种尺度的覆盖率计数器,包含指令级覆盖(Instructions, C0coverage)，分支（Branches, C1coverage）、圈复杂度(Cyclomatic Complexity)、行覆盖(Lines)、方法覆盖(non-abstract methods)、类覆盖(classes)。

jacoco支持多种覆盖率的统计，包括：

  1. 行覆盖率：度量被测程序的每行代码是否被执行，判断标准行中是否至少有一个指令被执行。

  2. 类覆盖率：度量计算class类文件是否被执行。

  3. 分支覆盖率：度量if和switch语句的分支覆盖情况，计算一个方法里面的总分支数，确定执行和不执行的 分支数量。

  4. 方法覆盖率：度量被测程序的方法执行情况，是否执行取决于方法中是否有至少一个指令被执行。

  5. 指令覆盖：计数单元是单个java二进制代码指令，指令覆盖率提供了代码是否被执行的信息，度量完全 独立源码格式。

  6. 圈复杂度：在（线性）组合中，计算在一个方法里面所有可能路径的最小数目，缺失的复杂度同样表示测试案例没有完全覆盖到这个模块。

在pom.xml文件中添加JaCoCo插件配置如下：

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>${jacoco.version}</version>
    <configuration>
        <!--针对符合下面的命名模式的测试类生成覆盖率报告-->
        <includes>
            <include>com/aa/bb/cc/service/inter/impl/StarServiceImpl*</include>
        </includes>
    </configuration>
    <!--在<executions>中配置执行步骤：
        1）prepare-agent（即构建jacoco-unit.exec）；
        2）check（即根据在<rules>定义的规矩进行检测）；
        3）package（生成覆盖率报告）
    -->
    <executions>
        <!-- 在maven的initialize阶段，将Jacoco运行时代理的属性作为VM的一个参数传给被测程序，用于监控JVM中的调用-->
        <execution>
            <id>pre-test</id>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
            <configuration>
                <propertyName>jacocoArgLine</propertyName>
            </configuration>
        </execution>
        <!--report:对代码进行检测，然后生成index.html-->
        <execution>
            <id>post-unit-test</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
            <configuration>
                <!--覆盖率报告的输出位置-->
                <outputDirectory>target/coverage-reports/jacoco-ut</outputDirectory>
                <!--指定生成.exec文件的存放位置-->
                <!--Jacoco是根据.exec文件生成最终的报告，所以需指定.exec的存放路径-->
                <dataFile>target/coverage-reports/jacoco-unit.exec</dataFile>
             </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M7</version>
    <configuration>
        <argLine>
             -javaagent:${settings.localRepository}/org/jacoco/org.jacoco.agent/${jacoco.version}/org.jacoco.agent-${jacoco.version}-runtime.jar=destfile=${project.basedir}/target/coverage-reports/jacoco-unit.exec
        </argLine>
        <!--执行测试源码路径(默认为sec/test/java/)下所有符合下面的命名模式的测试类-->
        <includes>
            <!--任何子目录下所有命名以StarServiceImplTest结尾的java类-->
            <include>**/*StarServiceImplTest.java</include>
            <include>**/*Spec</include>
        </includes>
    </configuration>
</plugin>

WebApplicationContext

  1. Spring容器负责管理Bean与Bean之间的依赖关系，Spring容器最基本的接口就是BeanFactory，BeanFactory负责配置、创建、管理Bean；
  2. ApplicationContext由BeanFactory派生而来，BeanFactory的许多功能需要编程实现，而在ApplicationContext中则可以通过配置的方式实现；
  3. ApplicationContext因此也称之为Spring上下文。

  • WebApplicationContext 接口扩展了ApplicationContext ，它是专门为 Web 应用设计的，但并意味着只有它才能为 Web应用服务；

  • WebApplicationContext是专门为web应用准备的，他允许从相对于web根目录的路径中装载配置文件完成初始化工作；

  • 从WebApplicationContext中可以获得ServletContext的引用，整个Web应用上下文对象将作为属性放置在ServletContext中，以便web应用可以访问spring上下文

  • spring中提供WebApplicationContextUtils的getWebApplicationContext(ServletContext src)方法来获得WebApplicationContext对象

stream流的map()方法

  • 函数式编程简单理解就是将方法作为参数传入，能够提高编写效率，减少代码冗余量
  • stream()是将list里面的数据变成流的形式，然后将每个list中的每个值传入到map中的方法中去并通过collect(Collectors.toList())构建成新的list
public class tt {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        List<Integer> listAdd = list.stream().map(s -> s + 2).collect(Collectors.toList());
        System.out.println(listAdd);
        //tt::add2 调用tt类的add2方法
        List<Integer> listAdd02 = list.stream().map(tt::add2).collect(Collectors.toList());
        System.out.println(listAdd02);
    }

    private static int add2(Integer temp){
        return  temp + 2;
    }
}

一些注解

@Async

@Async注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。

同步与异步的概念：

  • 同步：整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。例如， 在某个调用中，需要顺序调用 A, B, C三个过程方法，如果它们都是同步调用，则需要将它们都顺序执行完毕之后，才算作过程执行完毕；

  • 异步：只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕，而是继续执行下面的流程。例如， 在某个调用中，需要顺序调用 A, B, C三个过程方法，如果B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。

  • 在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

异步的方法有：

  1. 最简单的异步调用，返回值为void

  2. 带参数的异步调用，异步方法可以传入参数

  3. 存在返回值，常调用返回Future

@Async自定义线程池的方式：

  • 重新实现接口AsyncConfigurer

  • 继承AsyncConfigurerSupport

  • 配置由自定义的TaskExecutor替代内置的任务执行器

@Builder和@SuperBuilder

使用@Builder注解的优点：

  1. 代替若干参数情况下的构造函数，减少代码量；

  2. 通过Builder构造的方式，即.属性名(值)的方式，比直接使用构造函数的方式更具备可读性，比频繁使用set方式更简洁

public class builderStudy {
    Ming mingA = Ming.builder().build();
    Ming mingB = Ming.builder().age(11).name("BB").build();
}

@Builder
class Ming{
    private int age;
    private String name;
}

  1. 如果@Builder修饰的类是某个类的子类，那么之前调用的.builder()会报错，这是因为@Builder并不支持父类成员属性的构造

  2. @SuperBuilder可以解决这个问题，这样子类就可以正常获取到父类的成员属性进行builder构造了

public class builderStudy {
    Ming mingA = Ming.builder().build();
    Ming mingB = Ming.builder().age(11).name("BB").build();
}

@SuperBuilder
class Ming extends Person{

}

@SuperBuilder
class Person{
    private Integer age;
    private String name;
}

@SpringBootTest和@RunWith和@Test

@SpringBootTest 自动侦测并加载@SpringBootApplication或@SpringBootConfiguration中的配置，默认web环境为MOCK，不监听任务端口。使用 @SpringBootTest 后，Spring 将加载所有被管理的 bean，基本等同于启动了整个服务，此时便可以开始功能测试。

  • 如果单元测试类在测试包test下的路径与类路径Java下的路径一致的话，使用@SpringBootTest即可

  • 如果不一致，则使用@SpringBootTest(classes = xxx.class)指定启动类，启动spring容器，加载spring上下文ApplicationContext

@RunWith是 Junit4 提供的注解，如果测试类使用的是 Junit4 的 org.junit.Test，则需要加上@RunWith(SpringRunner.class)，如果没有的话，将导致service、dao等自动注入失败

@RunWith(SpringRunner.class)

  1. 指定Runner运行器;

  2. 与Spring环境整合

假如测试方法需要注入bean即需要spring环境，就在类上把@SpringBootTest和@RunWith这两个注解都带上

在方法上使用@Test注解，表示该方法为一个测试方法，可以不用main方法调用就可以测试出运行结果

注意：被测试的方法必须是public修饰的

@AutoWired和@Resource

自动装配是什么呢？简单来说：Spring 利用依赖注入（DI）功能，完成Spring IOC容器中各个组件之间的依赖关系赋值管理。

IOC操作Bean管理，bean管理是指（1）spring创建对象 （2）spring注入属性。当我们在将一个类上标注@Service或者@Controller或@Component或@Repository注解之后，spring的组件扫描就会自动发现它，并且会将其初始化为spring应用上下文中的bean。 而且初始化是根据无参构造函数。

@AutoWired  Spring 内置的注解

@Autowired 自动注入，将Spring IOC容器中已经注册好的对象注入到程序员定义的类型中，使其实例化（相当于new一个对象给定义的类型）并可用。@Autowired 可以对类成员变量（比较常见）、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。

@Autowired注解的注入规则：默认按照类型进行注入，如果找到的类型是唯一且匹配则返回这个对象并注入到用@Autowired标识的定义类型中，如果IOC容器中存在两个及以上的相同类型的bean时，则可以和@Qualifier搭配使用按照byName根据bean的名称进行注入，如果没有指定名称的bean，则会报错。

@Autowired
IAccountDao abc;

//1
@Service
public class AccountDao implements IAccountDao

//2
@Service(value = "abc")
public class AccountDao2 implements IAccountDao

  • @Autowired 首先会根据类型去Spring IOC容器去匹配与IAccountDao一致的类型，如果IAccountDao接口只有一个实现类AccountDao，由于匹配的类型是唯一的，那么向@Autowired标识的abc注入的即为AccountDao。

  • 如果IAccountDao接口有多个实现类AccountDao、AccountDao2，由于这两个实现类都实现了IAccountDao接口，很明显匹配到的类型是不唯一的，此时会根据属性的名称abc作为bean的id在IOC容器中查找，那么就可以搭配@Qualifier根据名称进行注入，直接指定要⾃动装配的bean的id。

@AutoWired
@Qualifier("abc")
IAccountDao iAccountDao

@Resource JDK 提供的注解

默认按照名称进行注入

@Resource(name = "abc")
IAccountDao iAccountDao

@Transactional

Spring事务管理

  • 方法：推荐将注解使用于方法上，不过需要注意的是：该注解只能应用到 public 方法上，否则不生效。
  • 类：如果这个注解使用在类上的话，表明该注解对该类中所有的 public 方法都生效。

事务的传播行为（7种），关注Propagation.REQUIRED、Propagation.REQUIRES_NEW、Propagation.NESTED

Propagation.REQUIRED（默认）

如果当前没有事务，就新建一个事务；如果已存在一个事务中，加入到这个事务中，共进退。

Propagation.REQUIRES_NEW

如果当前存在事务，那么将当前的事务挂起，并开启一个新事务去执行。

外部方法transTest()调用内部方法saveParent()（每次执行完都将info表和person表置为空）

外部方法用Propagation.REQUIRED修饰，内部方法用Propagation.REQUIRES_NEW修饰

  • 外部方法transTest()抛出异常，内部方法saveParent()正常
@Test
@Transactional(propagation = Propagation.REQUIRED)
public void transTest(){
    //向info表插入数据
    String insertQuery = "insert into info (id,phone,address) values (?,?,?)";
    List<Object[]> batchArgs=new ArrayList<>();
    batchArgs.add(new Object[]{1,"123", "china"});
    jdbcTemplate.batchUpdate(insertQuery, batchArgs);
    personService.saveParent(1, "A", 42);
    int a = 10 / 0;
}

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveParent(int id, String name, int age) {
    //向person表插入数据
    personMapper.insertPerson(id, name, age);

}

结果：外部方法回滚，内部方法正常提交

  • 外部方法transTest()正常，内部方法saveParent()抛出异常
@Test
@Transactional(propagation = Propagation.REQUIRED)
public void transTest(){
    //向info表插入数据
    String insertQuery = "insert into info (id,phone,address) values (?,?,?)";
    List<Object[]> batchArgs=new ArrayList<>();
    batchArgs.add(new Object[]{1,"123", "china"});
    jdbcTemplate.batchUpdate(insertQuery, batchArgs);
    personService.saveParent(1, "A", 42);
}

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveParent(int id, String name, int age) {
    //向person表插入数据
    personMapper.insertPerson(id, name, age);
    int a = 10 / 0;
}

结果：内部方法回滚，外部方法也回滚

Propagation.NESTED

如果当前存在事务，就在嵌套事务内执行；如果当前没有事务，就执行与Propagation.REQUIRED类似的操作，即新建事务。

外部方法用Propagation.REQUIRED修饰，内部方法用Propagation.NESTED修饰

  • 外部方法transTest()抛出异常，内部方法saveParent()正常
@Test
@Transactional(propagation = Propagation.REQUIRED)
public void transTest(){
    //向info表插入数据
    String insertQuery = "insert into info (id,phone,address) values (?,?,?)";
    List<Object[]> batchArgs=new ArrayList<>();
    batchArgs.add(new Object[]{1,"123", "china"});
    jdbcTemplate.batchUpdate(insertQuery, batchArgs);
    personService.saveParent(1, "A", 42);
    int a = 10 / 0;
}

@Override
@Transactional(propagation = Propagation.NESTED)
public void saveParent(int id, String name, int age) {
    //向person表插入数据
    personMapper.insertPerson(id, name, age);

}

结果：内部方法回滚，外部方法也回滚

  • 外部方法transTest()正常，内部方法saveParent()抛出异常
@Test
@Transactional(propagation = Propagation.REQUIRED)
public void transTest(){
    //向info表插入数据
    String insertQuery = "insert into info (id,phone,address) values (?,?,?)";
    List<Object[]> batchArgs=new ArrayList<>();
    batchArgs.add(new Object[]{1,"123", "china"});
    jdbcTemplate.batchUpdate(insertQuery, batchArgs);
    personService.saveParent(1, "A", 42);
}

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveParent(int id, String name, int age) {
    //向person表插入数据
    personMapper.insertPerson(id, name, age);
    int a = 10 / 0;
}

结果：内部方法回滚，外部方法也回滚

小结一下：

  • 区别在于，Propagation.REQUIRES_NEW的态度是外界纷纷扰扰与我何干，而Propagation.NESTED的态度是父子连坐
  • 相同的是，内部出了问题，外部连坐

@JSONField

  • @JSONField是fastjson的一个注解，在fastjson解析一个类为Json对象时，作用到类的每一个属性（field）上
  • 将一个类序列化为JSON对象时，通过使用@JSONField注解可以实现定义key等操作
public class Student {
    @JSONField(name = "student_name")
    private String name;

    @JSONField(name = "student_age")
    private int age;

    @JSONField(name = "student_id")
    private int id;

    @JSONField(name = "student_address")
    private String address;

    @JSONField(name = "student_phone_number")
    private String phoneNumber;
}
    public void stu(){
        Student stu = Student.builder().name("A").age(12).id(1).address("BB").address("1212").build();
        System.out.println(stu.toString());
        String jsonString = JSON.toJSONString(stu);
        System.out.println(jsonString);
    }

@NotBlank

字段校验注解

  • @NotNull：不能为 null，但可以为 empty，一般用在 Integer 类型的基本数据类型的非空校验上，而且被其标注的字段可以使用 @size、@Max、@Min 对字段数值进行大小的控制

  • @NotEmpty：不能为 null，且长度必须大于 0，一般用在集合类上或者数组上

  • @NotBlank：只能作用在String上，不能为null，而且调用trim()后，长度必须大于0

@ConfigurationProperties

@ConfigurationProperties需要和@Configuration配合使用

@Configuration
@ConfigurationProperties(prefix = "aa")
@Data
public class AAConfig {
  private String id;
  private String key;
  private String address;
}
aa:
  id: liu
  key: xxx
  address: baibai

上面的例子将会读取yml文件中所有以aa开头的属性，并和bean中的字段进行匹配

@Data

@Data可以标注在类上，提供类的get、set、equals、hashCode、canEqual、toString方法

作用：提高代码的简洁，使用这个注解可以省去代码中大量的get()、 set()、 toString()等方法

  • @Setter ： 注在属性上，提供 set 方法

  • @Getter ： 注在属性上，提供 get 方法

jijiup
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浪潮优派Python实习学习记录
03-26
浪潮优派Python实习学习记录
实习工作学习记录 MySQL
RonnyChan的博客
09-30 643
从8月27日起到现在，已经实习工作一个月了，这个月学到了很多技术知识，特此记录。 ----------------------------------------------------------------------------------- 1、连接语句 在pipeline.py中初始化类时连接数据库，相关变量在setting中已设置好 def __init__(self...
实习基础内容 学习记录
[2,+∞)的博客
07-29 1243
在有赞实习至今，准备大概记录一些在各个方面的学习，收获。大概可以从两个方面来概括： 一为实践项目开发中的一些常用工具，中间件知识等，简单来说是：从学校到实际开发的技术成长。 二为在实际开发过程中，经历了一个项目从立项到实际开发，再是联调测试的过程。并且学习到对于一些用户模型，角色的定义的过程。 技术成长：单元测试：对软件中的最小可测试单元进行检查和验证。 在对于项目熟悉过程中，对项目补充大量
硬件电路学习笔记1
2201_76037098的博客
04-02 97
注意单片机电路和驱动电路电流不同，一般分模块来进行连接。
研究生生涯实习记录
热门推荐
haohulala的博客
08-21 1万+
在写作这篇文章的时候，我已经提交了离职申请，离职之后，我的研究生实习生涯也就此告一段落了。谨以此文记录一下实习生涯中的付出与收获。读研可以说是我学生生涯的最后一个阶段了。刚刚入学的时候，导师请我们同门吃了一顿饭，吃饭的时候有研二的师兄师姐，还有我们几个青涩的研一同学，师门中唯独缺了研三的师兄。导师告诉我们，研三师兄去北京京东实习了，还告诉我们，只要我们完成论文，就可以去实习。师兄的经历和导师的保证，在我心里种下了一颗种子，我的目标非常明确，那就是完成论文，然后争取实习机会。确定了目标之后，我很快就投入到了写
深度学习实习生心得live_笔记.md
11-16
总结了一些深度学习实习的经验和心得，希望能够帮助到你，总结了一些深度学习实习的经验和心得，希望能够帮助到你
Vcore Trainee notes实习学习笔记，外企，全英文配图
01-16
实习学习笔记，外企，全英文配图
机器学习实践学习记录
08-08
机器学习实践学习记录是我在研究生刚开始接触机器学习领域的时候一些记录，希望能帮到需要的人
Java实习生面试复习(八)：volatile的学习
12-21
接下来的几个月内，我将坚持写博客，输出知识的同时巩固自己的基础，记录自己的成长和锻炼自己，备战2021暑期实习面试！奥利给！！ volatile也是多线程这块经常问到的基础问题，以volatile关键字作为一个小的切入点...
Linux 学习之路 -- 进程篇 -- 进程控制
2302_79538079的博客
04-24 1169
进程控制的简单介绍
力扣数据库题库学习（4.28日）--1587. 银行账户概要 II
Jesse_Kyrie的博客
04-28 176
对于力扣题1587. 银行账户概要 II的解答，提供解题思路与解题方法，知识点为:1. GROUP BY 2. SUM 3. LEFT JOIN 4. HAVING
党务学习|基于SprinBoot+vue的大学生党务学习平台(源码+数据库+文档)
伟庭的博客
04-27 719
大学生党务学习平台管理系统按照操作主体分为管理员和用户。用户的功能等。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。大学生党务学习平台管理系统可以提高大学生党务学习平台信息管理问题的解决效率，优化大学生党务学习平台信息处理流程，保证大学生党务学习平台信息数据的安全，它是一个非常可靠，非常安全的应用程序。大学生党务学习平台管理系统；入党申请,党课Mysql数据库；Java语言。
集成学习算法学习笔记
m0_46521579的博客
04-27 427
三个臭皮匠顶一个诸葛亮集成学习会考虑多个评估器的建模结果，汇总后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。很多独立的机器学习算法：决策树、神经网络、支持向量机集成学习构建了一组基学习器，并将它们综合起来作为最终的模型。在很多集成学习模型中，对基学习器的要求很低。集成学习适用于机器学习的几乎所有领域：回归、分类、推荐和排序。相同的多个基学习器不会带来任何提升，不同的模型取长补短，每个基学习器都会犯不同的错误，综合起来犯错的可能性不大。
PySide6 GUI 学习笔记——使用资源文件
Humbunklung的专栏
04-27 553
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
最新发布
weixin_66413741的博客
04-30 842
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Qt:学习笔记一
weixin_45930573的博客
04-25 1234
/槽函数，可以写到public slots，也可以写到public全局下//返回值void，需要声明，也需要实现//可以有参数，可以发生重载signals://自定义信号，写到signals下//返回值是void，只需要声明，不需要实现//可以有参数，可以重载qDebug() << "请老师吃饭";//QString->char * 先转成QByteArray (.toUtf8() ) 再转char * ()
JET毛选学习笔记：如何利用《矛盾论》从做实验到做科研vol. 1
qq_30452897的博客
04-27 882
JET毛选学习笔记：如何利用《矛盾论》从做实验到做科研vol. 1
NumPy简单学习（需要结合书本）
lenard-lhz的博客
04-25 517
需要之后来填坑😓😓😓简单使用numpy💕💕💕。
学习python的实习内容
07-17
在我学习Python的实习期间，我有机会将所学的知识应用到实际项目中，并从中获得宝贵的经验和技能。以下是我在实习期间的具体内容： 1. 项目开发：我参与了一个基于Python的软件开发项目。在这个项目中，我与团队...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值