Support: For-Each Loops, part 2 of 5

Loading...

Do curso por University of California San Diego

Estruturas dedados: medindo e otimizando o desempenho

1522 classificações

University of California San Diego

Estruturas dedados: medindo e otimizando o desempenho

1522 classificações

Curso 4 de 4 em Specialization Object Oriented Programming in Java

How do Java programs deal with vast quantities of data? Many of the data structures and algorithms that work with introductory toy examples break when applications process real, large data sets. Efficiency is critical, but how do we achieve it, and how do we even measure it? In this course, you will use and analyze data structures that are used in industry-level applications, such as linked lists, trees, and hashtables. You will explain how these data structures make programs more efficient and flexible. You will apply asymptotic Big-O analysis to describe the performance of algorithms and evaluate which strategy to use for efficient data retrieval, addition of new data, deletion of elements, and/or memory usage. The program you will build throughout this course allows its user to manage, manipulate and reason about large sets of textual data. This course is designed around the same video series as in our first course in this specialization, including explanations of core content, learner videos, student and engineer testimonials, and support videos -- to better allow you to choose your own path through the course!

Na lição

Working with Strings

This week we're going to dive into the course programming project. In the first lesson you'll learn about Strings and Regular Expressions, and in the programming assignment this week you'll apply that knowledge to adding functionality to your text editor so that it can measure the "readability" of text by calculating something called the "Flesch Readability Score". This course is focused on building code that not only does interesting things, but also finishes them quickly. So, let's get started building some code!

Core: Introduction to the Flesch Readability Score5:44

Core: Basics of Strings in Java6:21

Core: Working with Strings in Java8:44

Support: For-Each Loops, part 1 of 51:50

Support: For-Each Loops, part 2 of 54:37

Support: For-Each Loops, part 3 of 54:31

Support: For-Each Loops, part 4 of 59:52

Support: For-Each Loops, part 5 of 52:01

Core: Introduction to Regular Expressions10:29

When I struggled: Regular expressions1:44

Concept Challenge: Regular Expressions9:10

Support: More with Regular Expressions8:50

Conheça os instrutores

Christine Alvarado
Associate Teaching Professor
Computer Science and Engineering
Mia Minnes
Assistant Teaching Professor
Computer Science and Engineering
Leo Porter
Assistant Teaching Professor
Computer Science and Engineering

[APPLAUSE] >> So

let's trace through the execution of this particular implementation of the method.

And see what it does on a sample piece of input.

And then we'll have a sense of whether it's gonna work for us or not.

So when we're tracing through code, we're going to

use the concept of Memory Model Diagrams, and if you were with us for

course one of the specialization, this will be very familiar.

So what we're going to do here is illustrate the values of the variables and

how they change as we execute the code.

And so we're going to keep track of the scope of the variables in different parts

of our diagram.

So in this method we're going to be in the scope of replace,

which is the name of our method.

First, are the arguments or the parameters to this method.

And so we know we've got the word variable, and so we have a box next

to the name of the variable that is going to store the contents of that variable,

the other parameters are gone and here.

And in this particular example,

let's figure out what the values of these variables will be,

we're passing in a happy, which is a string to the variable word.

Now strings are objects in Java, which means over here in the heap.

When we put a happy in the quotes, we create a new string object.

And within that string object is the array of characters that are in that string.

And so we'll have that a happy.

Okay, so that's our string object living here in memory, and

when we pass that object into our method, what we're doing is we're creating

a reference from the variable to that object in the heap.

All right, so that's the first argument to our method.

The second two arguments are characters and those are primitive type data.

And so that means that when we pass them in we're actually

going to have copies of those characters that are stored in these variables.

So gone is the character a and here is the character i.

That's our memory model so far for this method.

Now we can go into the body of the method and see what happens.

The first line allocates space and memory for a character array.

And so we're going to have the variable

cArray as part of our memory model diagram.

And we have to figure out what to put in the box,

the value of that variable and that's the value that it's initialized to.

And what we see is that we are going to give that variable

the value of word.toCharArray.

And so what that means is we're calling the method toCharArray on the object word.

And so when we are trying to figure out where the methods are and

how they behave, we're following the dots, following the arrows.

And so we go to word, that's in our memory model over here,

and then we follow the arrow and we see that word refers to a string object.

And string objects have these methods toCharArray.

The return, well, they don't return the actual character array

that's stored in the object because strings are immutable.

So Java doesn't want us to have access to this particular CharArray.

Instead, it's going to create a copy of this character array, a memory,

and then return to us a pointer to this new array of characters.

And so cArray will point to this copy

of the character array that was stored in the string.

And so now we can go on to the rest of the method that we've written in replace,

and we notice that in this for loop, and

throughout the rest of the execution of the method,

all we're working with is cArray, and then characters associated with it.

And then at the end we're trying to return word.

And so what we're going to return is the object that was pointed

to by this variable, but all of our work is over here.

And so there's no way for us to change anything to do with this variable,

because all we're working with is the copy.

So in this method, what we return will just be

a pointer to the original string that we came with, and it won't have

had any of the functionality to it that we hoped for in the replace method.

In particular, all the a will still be a, they won't have magically turned into i.

And so this implementation is not going to work

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2019 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play